@eagleoutice/flowr 1.5.1 → 2.0.0

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

@@ -1,67 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Operators = exports.AssignmentsRAst = exports.Assignments = exports.ModelFormulaOperatorsRAst = exports.ModelFormulaOperators = exports.LogicalOperatorsRAst = exports.LogicalOperators = exports.ComparisonOperatorsRAst = exports.ComparisonOperators = exports.ArithmeticOperatorsRAst = exports.ArithmeticOperators = exports.OperatorDatabase = void 0;
+exports.UnaryOperatorsInRAst = exports.OperatorsInRAst = exports.Operators = exports.OperatorDatabase = void 0;
 /* eslint-disable */
 exports.OperatorDatabase = {
     /* model formulae */
-    '~': { name: 'model formulae', stringUsedInRAst: "~" /* RawRType.Tilde */, stringUsedInternally: '~', flavorInRAst: 'model formula', flavor: 'model formula', writtenAs: 'infix', arity: 3 /* OperatorArity.Both */, usedAs: 'operation' },
+    '~': { name: 'model formulae', stringUsedInRAst: "~" /* RawRType.Tilde */, stringUsedInternally: '~', writtenAs: 'infix', arity: 3 /* OperatorArity.Both */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'model-formula', 'function-calls'] },
     /* arithmetic */
-    '+': { name: 'addition or unary +', stringUsedInRAst: "+" /* RawRType.Plus */, stringUsedInternally: '+', flavorInRAst: 'arithmetic', flavor: 'arithmetic', writtenAs: 'infix', arity: 3 /* OperatorArity.Both */, usedAs: 'operation' },
-    '-': { name: 'subtraction or unary -', stringUsedInRAst: "-" /* RawRType.Minus */, stringUsedInternally: '-', flavorInRAst: 'arithmetic', flavor: 'arithmetic', writtenAs: 'infix', arity: 3 /* OperatorArity.Both */, usedAs: 'operation' },
-    '*': { name: 'multiplication', stringUsedInRAst: "*" /* RawRType.Times */, stringUsedInternally: '*', flavorInRAst: 'arithmetic', flavor: 'arithmetic', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '/': { name: 'division', stringUsedInRAst: "/" /* RawRType.Div */, stringUsedInternally: '/', flavorInRAst: 'arithmetic', flavor: 'arithmetic', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '^': { name: 'exponentiation', stringUsedInRAst: "^" /* RawRType.Exp */, stringUsedInternally: '^', flavorInRAst: 'arithmetic', flavor: 'arithmetic', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
+    '+': { name: 'addition or unary +', stringUsedInRAst: "+" /* RawRType.Plus */, stringUsedInternally: '+', writtenAs: 'infix', arity: 3 /* OperatorArity.Both */, usedAs: 'operation', capabilities: ['function-calls'] },
+    '-': { name: 'subtraction or unary -', stringUsedInRAst: "-" /* RawRType.Minus */, stringUsedInternally: '-', writtenAs: 'infix', arity: 3 /* OperatorArity.Both */, usedAs: 'operation', capabilities: ['function-calls'] },
+    '*': { name: 'multiplication', stringUsedInRAst: "*" /* RawRType.Times */, stringUsedInternally: '*', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '/': { name: 'division', stringUsedInRAst: "/" /* RawRType.Div */, stringUsedInternally: '/', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '^': { name: 'exponentiation', stringUsedInRAst: "^" /* RawRType.Exp */, stringUsedInternally: '^', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
     /* no error, R uses ^ to represent ** in the AST */
-    '**': { name: 'alternative exponentiation', stringUsedInRAst: "^" /* RawRType.Exp */, stringUsedInternally: '**', flavorInRAst: 'arithmetic', flavor: 'arithmetic', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '%%': { name: 'modulus', stringUsedInRAst: '%%', stringUsedInternally: '%%', flavorInRAst: 'special', flavor: 'arithmetic', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '%/%': { name: 'integer division', stringUsedInRAst: '%/%', stringUsedInternally: '%/%', flavorInRAst: 'special', flavor: 'arithmetic', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '%*%': { name: 'matrix product', stringUsedInRAst: '%*%', stringUsedInternally: '%*%', flavorInRAst: 'special', flavor: 'arithmetic', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '%o%': { name: 'outer product', stringUsedInRAst: '%o%', stringUsedInternally: '%o%', flavorInRAst: 'special', flavor: 'arithmetic', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '%x%': { name: 'kronecker product', stringUsedInRAst: '%x%', stringUsedInternally: '%x%', flavorInRAst: 'special', flavor: 'arithmetic', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
+    '**': { name: 'alternative exponentiation', stringUsedInRAst: "^" /* RawRType.Exp */, stringUsedInternally: '**', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '%%': { name: 'modulus', stringUsedInRAst: '%%', stringUsedInternally: '%%', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'special-operator', 'function-calls'] },
+    '%/%': { name: 'integer division', stringUsedInRAst: '%/%', stringUsedInternally: '%/%', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'special-operator', 'function-calls'] },
+    '%*%': { name: 'matrix product', stringUsedInRAst: '%*%', stringUsedInternally: '%*%', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'special-operator', 'function-calls'] },
+    '%o%': { name: 'outer product', stringUsedInRAst: '%o%', stringUsedInternally: '%o%', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'special-operator', 'function-calls'] },
+    '%x%': { name: 'kronecker product', stringUsedInRAst: '%x%', stringUsedInternally: '%x%', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'special-operator', 'function-calls'] },
     /* comparison */
-    '==': { name: 'equal to', stringUsedInRAst: "EQ" /* RawRType.Eq */, stringUsedInternally: '==', flavorInRAst: 'comparison', flavor: 'comparison', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '!=': { name: 'not equal to', stringUsedInRAst: "NE" /* RawRType.Ne */, stringUsedInternally: '!=', flavorInRAst: 'comparison', flavor: 'comparison', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '>': { name: 'greater than', stringUsedInRAst: "GT" /* RawRType.Gt */, stringUsedInternally: '>', flavorInRAst: 'comparison', flavor: 'comparison', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '>=': { name: 'greater than or equal to', stringUsedInRAst: "GE" /* RawRType.Ge */, stringUsedInternally: '>=', flavorInRAst: 'comparison', flavor: 'comparison', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '<': { name: 'less than', stringUsedInRAst: "LT" /* RawRType.Lt */, stringUsedInternally: '<', flavorInRAst: 'comparison', flavor: 'comparison', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '<=': { name: 'less than or equal to', stringUsedInRAst: "LE" /* RawRType.Le */, stringUsedInternally: '<=', flavorInRAst: 'comparison', flavor: 'comparison', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
+    '==': { name: 'equal to', stringUsedInRAst: "EQ" /* RawRType.Eq */, stringUsedInternally: '==', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '!=': { name: 'not equal to', stringUsedInRAst: "NE" /* RawRType.Ne */, stringUsedInternally: '!=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '>': { name: 'greater than', stringUsedInRAst: "GT" /* RawRType.Gt */, stringUsedInternally: '>', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '>=': { name: 'greater than or equal to', stringUsedInRAst: "GE" /* RawRType.Ge */, stringUsedInternally: '>=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '<': { name: 'less than', stringUsedInRAst: "LT" /* RawRType.Lt */, stringUsedInternally: '<', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '<=': { name: 'less than or equal to', stringUsedInRAst: "LE" /* RawRType.Le */, stringUsedInternally: '<=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
     /* logical */
-    '&': { name: 'logical and (vectorized)', stringUsedInRAst: "AND" /* RawRType.And */, stringUsedInternally: '&', flavorInRAst: 'logical', flavor: 'logical', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '&&': { name: 'logical and (non-vectorized)', stringUsedInRAst: "AND2" /* RawRType.And2 */, stringUsedInternally: '&&', flavorInRAst: 'logical', flavor: 'logical', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '|': { name: 'logical or (vectorized)', stringUsedInRAst: "OR" /* RawRType.Or */, stringUsedInternally: '|', flavorInRAst: 'logical', flavor: 'logical', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '||': { name: 'logical or (not-vectorized)', stringUsedInRAst: "OR2" /* RawRType.Or2 */, stringUsedInternally: '||', flavorInRAst: 'logical', flavor: 'logical', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '!': { name: 'unary not', stringUsedInRAst: "!" /* RawRType.Exclamation */, stringUsedInternally: '!', flavorInRAst: 'logical', flavor: 'logical', writtenAs: 'prefix', arity: 1 /* OperatorArity.Unary */, usedAs: 'operation' },
-    '%in%': { name: 'matching operator', stringUsedInRAst: '%in%', stringUsedInternally: '%in%', flavorInRAst: 'special', flavor: 'logical', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
+    '&': { name: 'logical and (vectorized)', stringUsedInRAst: "AND" /* RawRType.And */, stringUsedInternally: '&', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls', 'non-strict-logical-operators'] },
+    '&&': { name: 'logical and (non-vectorized)', stringUsedInRAst: "AND2" /* RawRType.And2 */, stringUsedInternally: '&&', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls', 'non-strict-logical-operators'] },
+    '|': { name: 'logical or (vectorized)', stringUsedInRAst: "OR" /* RawRType.Or */, stringUsedInternally: '|', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls', 'non-strict-logical-operators'] },
+    '||': { name: 'logical or (not-vectorized)', stringUsedInRAst: "OR2" /* RawRType.Or2 */, stringUsedInternally: '||', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls', 'non-strict-logical-operators'] },
+    '!': { name: 'unary not', stringUsedInRAst: "!" /* RawRType.Exclamation */, stringUsedInternally: '!', writtenAs: 'prefix', arity: 1 /* OperatorArity.Unary */, usedAs: 'operation', capabilities: ['unary-operator', 'function-calls'] },
+    '%in%': { name: 'matching operator', stringUsedInRAst: '%in%', stringUsedInternally: '%in%', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'special-operator', 'function-calls'] },
     /* assignment */
-    '<-': { name: 'left assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: '<-', flavorInRAst: 'special', flavor: 'assignment', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment' },
-    ':=': { name: 'left assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: ':=', flavorInRAst: 'special', flavor: 'assignment', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment' },
-    '<<-': { name: 'left global assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: '<<-', flavorInRAst: 'special', flavor: 'assignment', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment' },
-    '->': { name: 'right assignment', stringUsedInRAst: "RIGHT_ASSIGN" /* RawRType.RightAssign */, stringUsedInternally: '->', flavorInRAst: 'special', flavor: 'assignment', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment' },
-    '->>': { name: 'right global assignment', stringUsedInRAst: "RIGHT_ASSIGN" /* RawRType.RightAssign */, stringUsedInternally: '->>', flavorInRAst: 'special', flavor: 'assignment', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment' },
-    '=': { name: 'equal assignment', stringUsedInRAst: "EQ_ASSIGN" /* RawRType.EqualAssign */, stringUsedInternally: '=', flavorInRAst: 'special', flavor: 'assignment', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment' },
+    '<-': { name: 'left assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: '<-', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-left-assignment', 'function-calls'] },
+    ':=': { name: 'left assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: ':=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-equal-assignment', 'function-calls'] },
+    '<<-': { name: 'left global assignment', stringUsedInRAst: "LEFT_ASSIGN" /* RawRType.LeftAssign */, stringUsedInternally: '<<-', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'super-left-assignment', 'function-calls'] },
+    '->': { name: 'right assignment', stringUsedInRAst: "RIGHT_ASSIGN" /* RawRType.RightAssign */, stringUsedInternally: '->', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-right-assignment', 'function-calls'] },
+    '->>': { name: 'right global assignment', stringUsedInRAst: "RIGHT_ASSIGN" /* RawRType.RightAssign */, stringUsedInternally: '->>', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'super-right-assignment', 'function-calls'] },
+    '=': { name: 'equal assignment', stringUsedInRAst: "EQ_ASSIGN" /* RawRType.EqualAssign */, stringUsedInternally: '=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-equal-assignment', 'function-calls'] },
     /* others */
     /* maybe introduce custom in-r-ast flavor for these? we consider it arithmetic, as it works on numbers => if we change this we have to create custom tests! (with arithmetic, there is the automatic test set) */
-    ':': { name: 'sequence operator', stringUsedInRAst: ":" /* RawRType.Colon */, stringUsedInternally: ':', flavorInRAst: 'special', flavor: 'arithmetic', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation' },
-    '?': { name: 'question', stringUsedInRAst: "?" /* RawRType.Question */, stringUsedInternally: '?', flavorInRAst: 'special', flavor: 'logical', writtenAs: 'prefix', arity: 1 /* OperatorArity.Unary */, usedAs: 'operation' }
+    ':': { name: 'sequence operator', stringUsedInRAst: ":" /* RawRType.Colon */, stringUsedInternally: ':', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls', 'built-in-sequencing'] },
+    '?': { name: 'question', stringUsedInRAst: "?" /* RawRType.Question */, stringUsedInternally: '?', writtenAs: 'prefix', arity: 1 /* OperatorArity.Unary */, usedAs: 'operation', capabilities: ['unary-operator', 'built-in-help'] }
 };
 /* eslint-enable */
 function buildOperatorRAstCollection(operators) {
     return new Set(operators.map(op => exports.OperatorDatabase[op].stringUsedInRAst));
 }
-exports.ArithmeticOperators = Object.keys(exports.OperatorDatabase).filter((op) => exports.OperatorDatabase[op].flavor === 'arithmetic');
+exports.Operators = Object.keys(exports.OperatorDatabase);
 // '**' will be treated as '^'
-exports.ArithmeticOperatorsRAst = buildOperatorRAstCollection(exports.ArithmeticOperators);
-exports.ComparisonOperators = Object.keys(exports.OperatorDatabase).filter((op) => exports.OperatorDatabase[op].flavor === 'comparison');
-exports.ComparisonOperatorsRAst = buildOperatorRAstCollection(exports.ComparisonOperators);
-exports.LogicalOperators = Object.keys(exports.OperatorDatabase).filter((op) => exports.OperatorDatabase[op].flavor === 'logical');
-exports.LogicalOperatorsRAst = buildOperatorRAstCollection(exports.LogicalOperators);
-exports.ModelFormulaOperators = Object.keys(exports.OperatorDatabase).filter((op) => exports.OperatorDatabase[op].flavor === 'model formula');
-exports.ModelFormulaOperatorsRAst = buildOperatorRAstCollection(exports.ModelFormulaOperators);
-exports.Assignments = Object.keys(exports.OperatorDatabase).filter((op) => exports.OperatorDatabase[op].flavor === 'assignment');
-exports.AssignmentsRAst = buildOperatorRAstCollection(exports.Assignments);
-exports.Operators = [
-    ...exports.ArithmeticOperators,
-    ...exports.ComparisonOperators,
-    ...exports.LogicalOperators,
-];
+exports.OperatorsInRAst = buildOperatorRAstCollection(exports.Operators);
+exports.UnaryOperatorsInRAst = buildOperatorRAstCollection(exports.Operators.filter(op => exports.OperatorDatabase[op].arity !== 2 /* OperatorArity.Binary */));
 //# sourceMappingURL=operators.js.map

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

@@ -13,10 +13,8 @@ import type { SourceRange } from '../../../../../util/range';
 import { BiMap } from '../../../../../util/bimap';
 import type { MergeableRecord } from '../../../../../util/objects';
 import { RoleInParent } from './role';
-/** The type of the id assigned to each node. Branded to avoid problematic usages with other string types. */
-export type NodeId = string & {
-    __brand?: 'node-id';
-};
+import type { NodeId } from './node-id';
+import type { RDelimiter } from '../nodes/info/r-delimiter';
 /**
  * A function that given an RNode returns a (guaranteed) unique id for it
  * @param data - the node to generate an id for
@@ -27,27 +25,33 @@ export type IdGenerator<OtherInfo> = (data: RNode<OtherInfo>) => NodeId;
 /**
  * The simplest id generator which just increments a number on each call.
  */
-export declare function deterministicCountingIdGenerator(start?: number): () => NodeId;
+export declare function deterministicCountingIdGenerator(id?: number): () => NodeId;
 export declare function sourcedDeterministicCountingIdGenerator(path: string, location: SourceRange, start?: number): () => NodeId;
 /**
  * Generates the location id, used by {@link deterministicLocationIdGenerator}.
  *
  * @param data - the node to generate an id for, must have location information
  */
-export declare function nodeToLocationId<OtherInfo>(data: RNode<OtherInfo>): NodeId;
+export declare function nodeToLocationId<OtherInfo>(data: RNode<OtherInfo> | RDelimiter): NodeId;
 /**
  * Generates unique ids based on the locations of the node (see {@link nodeToLocationId}).
- * If a node has no location information, it will be assigned a unique counter value.
+ * If a node has no location information, it will be assigned a unique counter-value.
  *
- * @param start - the start value for the counter in case nodes do not have a location information
+ * @param start - the start value for the counter, in case nodes do not have location information
  */
 export declare function deterministicLocationIdGenerator<OtherInfo>(start?: number): IdGenerator<OtherInfo>;
 export interface ParentContextInfo extends MergeableRecord {
     role: RoleInParent;
     /**
-     * 0-based index of the child in the parent (code semantics, e.g., for an if-then-else, the condition will be 0, the then-case 1, ...)
+     * The depth of the node in the AST
      *
-     * The index is adaptive, that means that if the name of an argument exists, it will have the index 0, and the value the index 1.
+     * The root node has a depth of 0, its children a depth of 1, and so on.
+     */
+    depth: number;
+    /**
+     * 0-based index of the child in the parent (code semantics, e.g., for an if-then-else, the condition will be 0, the then-case will be 1, ...)
+     *
+     * The index is adaptive, that means that if the name of an argument exists, it will have index 0, and the value will have index 1.
      * But if the argument is unnamed, its value will get the index 0 instead.
      */
     index: number;
@@ -59,16 +63,16 @@ export interface ParentInformation extends ParentContextInfo {
     parent: NodeId | undefined;
 }
 export type RNodeWithParent<OtherInfo = NoInfo> = RNode<OtherInfo & ParentInformation>;
-export type DecoratedAstMap<OtherInfo = NoInfo> = BiMap<NodeId, RNodeWithParent<OtherInfo>>;
+export type AstIdMap<OtherInfo = NoInfo> = BiMap<NodeId, RNodeWithParent<OtherInfo>>;
 /**
  * Contains the normalized AST as a doubly linked tree
  * and a map from ids to nodes so that parent links can be chased easily.
  */
-export interface NormalizedAst<OtherInfo = ParentInformation> {
+export interface NormalizedAst<OtherInfo = ParentInformation, Node = RNode<OtherInfo & ParentInformation>> {
     /** Bidirectional mapping of ids to the corresponding nodes and the other way */
-    idMap: DecoratedAstMap<OtherInfo>;
+    idMap: AstIdMap<OtherInfo>;
     /** The root of the AST with parent information */
-    ast: RNodeWithParent<OtherInfo>;
+    ast: Node;
 }
 /**
  * Covert the given AST into a doubly linked tree while assigning ids (so it stays serializable).
@@ -78,6 +82,6 @@ export interface NormalizedAst<OtherInfo = ParentInformation> {
  *
  * @typeParam OtherInfo - The original decoration of the ast nodes (probably is nothing as the id decoration is most likely the first step to be performed after extraction)
  *
- * @returns A {@link DecoratedAst | decorated AST} based on the input and the id provider.
+ * @returns A decorated AST based on the input and the id provider.
  */
 export declare function decorateAst<OtherInfo = NoInfo>(ast: RNode<OtherInfo>, getId?: IdGenerator<OtherInfo>): NormalizedAst<OtherInfo & ParentInformation>;

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

@@ -13,13 +13,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.decorateAst = exports.deterministicLocationIdGenerator = exports.nodeToLocationId = exports.sourcedDeterministicCountingIdGenerator = exports.deterministicCountingIdGenerator = void 0;
 const assert_1 = require("../../../../../util/assert");
 const bimap_1 = require("../../../../../util/bimap");
-const fold_1 = require("./fold");
+const stateful_fold_1 = require("./stateful-fold");
+const r_function_call_1 = require("../nodes/r-function-call");
 /**
  * The simplest id generator which just increments a number on each call.
  */
-function deterministicCountingIdGenerator(start = 0) {
-    let id = start;
-    return () => `${id++}`;
+function deterministicCountingIdGenerator(id = 0) {
+    return () => id++;
 }
 exports.deterministicCountingIdGenerator = deterministicCountingIdGenerator;
 function sourcedDeterministicCountingIdGenerator(path, location, start = 0) {
@@ -27,8 +27,8 @@ function sourcedDeterministicCountingIdGenerator(path, location, start = 0) {
     return () => `${path}-${loc2Id(location)}-${id++}`;
 }
 exports.sourcedDeterministicCountingIdGenerator = sourcedDeterministicCountingIdGenerator;
-function loc2Id(loc) {
-    return `${loc.start.line}:${loc.start.column}-${loc.end.line}:${loc.end.column}`;
+function loc2Id([sl, sc, el, ec]) {
+    return `${sl}:${sc}-${el}:${ec}`;
 }
 /**
  * Generates the location id, used by {@link deterministicLocationIdGenerator}.
@@ -43,16 +43,19 @@ function nodeToLocationId(data) {
 exports.nodeToLocationId = nodeToLocationId;
 /**
  * Generates unique ids based on the locations of the node (see {@link nodeToLocationId}).
- * If a node has no location information, it will be assigned a unique counter value.
+ * If a node has no location information, it will be assigned a unique counter-value.
  *
- * @param start - the start value for the counter in case nodes do not have a location information
+ * @param start - the start value for the counter, in case nodes do not have location information
  */
 function deterministicLocationIdGenerator(start = 0) {
     let id = start;
     return (data) => data.location !== undefined ? nodeToLocationId(data) : `${id++}`;
 }
 exports.deterministicLocationIdGenerator = deterministicLocationIdGenerator;
-const defaultParentContext = { role: "root" /* RoleInParent.Root */, index: 0 };
+const defaultParentContext = {
+    role: "root" /* RoleInParent.Root */,
+    index: 0
+};
 /**
  * Covert the given AST into a doubly linked tree while assigning ids (so it stays serializable).
  *
@@ -61,34 +64,26 @@ const defaultParentContext = { role: "root" /* RoleInParent.Root */, index: 0 };
  *
  * @typeParam OtherInfo - The original decoration of the ast nodes (probably is nothing as the id decoration is most likely the first step to be performed after extraction)
  *
- * @returns A {@link DecoratedAst | decorated AST} based on the input and the id provider.
+ * @returns A decorated AST based on the input and the id provider.
  */
 function decorateAst(ast, getId = deterministicCountingIdGenerator(0)) {
     const idMap = new bimap_1.BiMap();
     const info = { idMap, getId };
-    /* Please note, that all fold processors do not re-create copies in higher folding steps so that the idMap stays intact. */
+    /* Please note, that all fold processors do not re-create copies in higher-folding steps so that the idMap stays intact. */
     const foldLeaf = createFoldForLeaf(info);
     const foldBinaryOp = createFoldForBinaryOp(info);
     const unaryOp = createFoldForUnaryOp(info);
-    const decoratedAst = (0, fold_1.foldAst)(ast, {
+    /* we pass down the depth */
+    const decoratedAst = (0, stateful_fold_1.foldAstStateful)(ast, -1, {
+        down: (_, down) => down + 1,
         foldNumber: foldLeaf,
         foldString: foldLeaf,
         foldLogical: foldLeaf,
         foldSymbol: foldLeaf,
         foldAccess: createFoldForAccess(info),
-        binaryOp: {
-            foldLogicalOp: foldBinaryOp,
-            foldArithmeticOp: foldBinaryOp,
-            foldComparisonOp: foldBinaryOp,
-            foldAssignment: foldBinaryOp,
-            foldPipe: foldBinaryOp,
-            foldModelFormula: foldBinaryOp
-        },
-        unaryOp: {
-            foldArithmeticOp: unaryOp,
-            foldLogicalOp: unaryOp,
-            foldModelFormula: unaryOp
-        },
+        foldBinaryOp: foldBinaryOp,
+        foldPipe: foldBinaryOp,
+        foldUnaryOp: unaryOp,
         other: {
             foldComment: foldLeaf,
             foldLineDirective: foldLeaf
@@ -118,17 +113,26 @@ function decorateAst(ast, getId = deterministicCountingIdGenerator(0)) {
 }
 exports.decorateAst = decorateAst;
 function createFoldForLeaf(info) {
-    return (data) => {
+    return (data, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined, ...defaultParentContext } };
+        const decorated = {
+            ...data,
+            info: {
+                ...data.info,
+                id,
+                parent: undefined,
+                ...defaultParentContext,
+                depth
+            }
+        };
         info.idMap.set(id, decorated);
         return decorated;
     };
 }
 function createFoldForBinaryOp(info) {
-    return (data, lhs, rhs) => {
+    return (data, lhs, rhs, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, lhs, rhs };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, lhs, rhs };
         info.idMap.set(id, decorated);
         const lhsInfo = lhs.info;
         lhsInfo.parent = id;
@@ -147,9 +151,9 @@ function createFoldForBinaryOp(info) {
     };
 }
 function createFoldForUnaryOp(info) {
-    return (data, operand) => {
+    return (data, operand, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, operand };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, operand };
         info.idMap.set(id, decorated);
         const opInfo = operand.info;
         opInfo.parent = id;
@@ -158,9 +162,9 @@ function createFoldForUnaryOp(info) {
     };
 }
 function createFoldForAccess(info) {
-    return (data, accessed, access) => {
+    return (data, accessed, access, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, accessed, access };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, accessed, access };
         info.idMap.set(id, decorated);
         const accessedInfo = accessed.info;
         accessedInfo.parent = id;
@@ -169,7 +173,7 @@ function createFoldForAccess(info) {
             let idx = 0; // the first oe will be skipped in the first iter
             for (const acc of access) {
                 idx++;
-                if (acc !== null) {
+                if (acc !== r_function_call_1.EmptyArgument) {
                     const curInfo = acc.info;
                     curInfo.parent = id;
                     curInfo.index = idx;
@@ -181,9 +185,9 @@ function createFoldForAccess(info) {
     };
 }
 function createFoldForForLoop(info) {
-    return (data, variable, vector, body) => {
+    return (data, variable, vector, body, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, variable, vector, body };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, variable, vector, body };
         info.idMap.set(id, decorated);
         const varInfo = variable.info;
         varInfo.parent = id;
@@ -200,9 +204,9 @@ function createFoldForForLoop(info) {
     };
 }
 function createFoldForRepeatLoop(info) {
-    return (data, body) => {
+    return (data, body, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, body };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, body };
         info.idMap.set(id, decorated);
         const bodyInfo = body.info;
         bodyInfo.parent = id;
@@ -211,9 +215,9 @@ function createFoldForRepeatLoop(info) {
     };
 }
 function createFoldForWhileLoop(info) {
-    return (data, condition, body) => {
+    return (data, condition, body, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, condition, body };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, condition, body };
         info.idMap.set(id, decorated);
         const condInfo = condition.info;
         condInfo.parent = id;
@@ -226,9 +230,9 @@ function createFoldForWhileLoop(info) {
     };
 }
 function createFoldForIfThenElse(info) {
-    return (data, condition, then, otherwise) => {
+    return (data, condition, then, otherwise, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, condition, then, otherwise };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, condition, then, otherwise };
         info.idMap.set(id, decorated);
         const condInfo = condition.info;
         condInfo.parent = id;
@@ -247,9 +251,9 @@ function createFoldForIfThenElse(info) {
     };
 }
 function createFoldForExprList(info) {
-    return (data, children) => {
+    return (data, grouping, children, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, children };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, grouping, children };
         info.idMap.set(id, decorated);
         let i = 0;
         for (const child of children) {
@@ -262,14 +266,14 @@ function createFoldForExprList(info) {
     };
 }
 function createFoldForFunctionCall(info) {
-    return (data, functionName, args) => {
+    return (data, functionName, args, depth) => {
         const id = info.getId(data);
         let decorated;
         if (data.flavor === 'named') {
-            decorated = { ...data, info: { ...data.info, id, parent: undefined }, functionName, arguments: args };
+            decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, functionName, arguments: args };
         }
         else {
-            decorated = { ...data, info: { ...data.info, id, parent: undefined }, calledFunction: functionName, arguments: args };
+            decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, calledFunction: functionName, arguments: args };
         }
         info.idMap.set(id, decorated);
         const funcInfo = functionName.info;
@@ -278,19 +282,20 @@ function createFoldForFunctionCall(info) {
         let idx = 0;
         for (const arg of args) {
             idx++;
-            if (arg !== undefined) {
+            if (arg !== r_function_call_1.EmptyArgument) {
                 const argInfo = arg.info;
                 argInfo.parent = id;
                 argInfo.index = idx;
+                argInfo.role = "call-argument" /* RoleInParent.FunctionCallArgument */;
             }
         }
         return decorated;
     };
 }
 function createFoldForFunctionDefinition(info) {
-    return (data, params, body) => {
+    return (data, params, body, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, parameters: params, body };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, parameters: params, body };
         info.idMap.set(id, decorated);
         let idx = 0;
         for (const param of params) {
@@ -307,9 +312,9 @@ function createFoldForFunctionDefinition(info) {
     };
 }
 function createFoldForFunctionParameter(info) {
-    return (data, name, defaultValue) => {
+    return (data, name, defaultValue, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, name, defaultValue };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, name, defaultValue };
         info.idMap.set(id, decorated);
         const nameInfo = name.info;
         nameInfo.parent = id;
@@ -324,9 +329,9 @@ function createFoldForFunctionParameter(info) {
     };
 }
 function createFoldForFunctionArgument(info) {
-    return (data, name, value) => {
+    return (data, name, value, depth) => {
         const id = info.getId(data);
-        const decorated = { ...data, info: { ...data.info, id, parent: undefined }, name, value };
+        const decorated = { ...data, info: { ...data.info, id, parent: undefined, depth }, name, value };
         info.idMap.set(id, decorated);
         let idx = 0;
         if (name) {

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

@@ -0,0 +1,8 @@
+import type { AstIdMap } from './decorate';
+/** The type of the id assigned to each node. Branded to avoid problematic usages with other string or numeric types. */
+export type NodeId<T extends string | number = string | number> = T & {
+    __brand?: 'node-id';
+};
+/** used so that we do not have to store strings for the default numeric ids */
+export declare function normalizeIdToNumberIfPossible(id: NodeId): NodeId;
+export declare function recoverName(id: NodeId, idMap?: AstIdMap): string | undefined;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoverName = exports.normalizeIdToNumberIfPossible = void 0;
+const numIdRegex = /^\d+$/;
+/** used so that we do not have to store strings for the default numeric ids */
+function normalizeIdToNumberIfPossible(id) {
+    // check if string is number
+    if (typeof id === 'string' && numIdRegex.test(id)) {
+        return Number(id);
+    }
+    return id;
+}
+exports.normalizeIdToNumberIfPossible = normalizeIdToNumberIfPossible;
+function recoverName(id, idMap) {
+    return idMap?.get(id)?.lexeme;
+}
+exports.recoverName = recoverName;
+//# sourceMappingURL=node-id.js.map

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

@@ -1,4 +1,4 @@
-import type { DecoratedAstMap, RNodeWithParent } from './decorate';
+import type { AstIdMap, RNodeWithParent } from './decorate';
 /**
  * Describes the role of the node in its parent. For example,
  * if we have `if(TRUE) { ... }`, the role of the `TRUE` node is `IfCondition`.
@@ -38,4 +38,4 @@ export declare const enum RoleInParent {
 /**
  * Returns the roles of the parents of the given node, starting with the parent-role of the node itself.
  */
-export declare function rolesOfParents(node: RNodeWithParent, idMap: DecoratedAstMap): RoleInParent[];
+export declare function rolesOfParents(node: RNodeWithParent, idMap: AstIdMap): RoleInParent[];

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

@@ -1,6 +1,27 @@
 import type { DeepReadonly } from 'ts-essentials';
-import type { RExpressionList, RNumber, RSymbol, RLogical, RString, RArithmeticBinaryOp, RAssignmentOp, RComparisonBinaryOp, RLogicalBinaryOp, RArithmeticUnaryOp, RLogicalUnaryOp, RIfThenElse, RForLoop, RRepeatLoop, RWhileLoop, RFunctionCall, RComment, RNext, RBreak, RParameter, RArgument, RFunctionDefinition, RAccess, RModelFormulaBinaryOp, RModelFormulaUnaryOp, RLineDirective, RPipe } from '../nodes';
 import type { RNode } from '../model';
+import type { RNumber } from '../nodes/r-number';
+import type { RString } from '../nodes/r-string';
+import type { RLogical } from '../nodes/r-logical';
+import type { RSymbol } from '../nodes/r-symbol';
+import type { RAccess } from '../nodes/r-access';
+import type { RBinaryOp } from '../nodes/r-binary-op';
+import type { RPipe } from '../nodes/r-pipe';
+import type { RUnaryOp } from '../nodes/r-unary-op';
+import type { RFunctionCall } from '../nodes/r-function-call';
+import { EmptyArgument } from '../nodes/r-function-call';
+import type { RForLoop } from '../nodes/r-for-loop';
+import type { RWhileLoop } from '../nodes/r-while-loop';
+import type { RRepeatLoop } from '../nodes/r-repeat-loop';
+import type { RNext } from '../nodes/r-next';
+import type { RBreak } from '../nodes/r-break';
+import type { RComment } from '../nodes/r-comment';
+import type { RLineDirective } from '../nodes/r-line-directive';
+import type { RIfThenElse } from '../nodes/r-if-then-else';
+import type { RExpressionList } from '../nodes/r-expression-list';
+import type { RFunctionDefinition } from '../nodes/r-function-definition';
+import type { RArgument } from '../nodes/r-argument';
+import type { RParameter } from '../nodes/r-parameter';
 /**
  * Called during the down-pass, will pe propagated to children and used in the up-pass (see {@link StatefulFoldFunctions}).
  * <p>
@@ -17,20 +38,10 @@ export interface StatefulFoldFunctions<Info, Down, Up> {
     foldString: (str: RString<Info>, down: Down) => Up;
     foldLogical: (logical: RLogical<Info>, down: Down) => Up;
     foldSymbol: (symbol: RSymbol<Info>, down: Down) => Up;
-    foldAccess: (node: RAccess<Info>, name: Up, access: string | (null | Up)[], down: Down) => Up;
-    binaryOp: {
-        foldLogicalOp: (op: RLogicalBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
-        foldArithmeticOp: (op: RArithmeticBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
-        foldComparisonOp: (op: RComparisonBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
-        foldAssignment: (op: RAssignmentOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
-        foldPipe: (op: RPipe<Info>, lhs: Up, rhs: Up, down: Down) => Up;
-        foldModelFormula: (op: RModelFormulaBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
-    };
-    unaryOp: {
-        foldLogicalOp: (op: RLogicalUnaryOp<Info>, operand: Up, down: Down) => Up;
-        foldArithmeticOp: (op: RArithmeticUnaryOp<Info>, operand: Up, down: Down) => Up;
-        foldModelFormula: (op: RModelFormulaUnaryOp<Info>, operand: Up, down: Down) => Up;
-    };
+    foldAccess: (node: RAccess<Info>, name: Up, access: readonly (typeof EmptyArgument | Up)[], down: Down) => Up;
+    foldBinaryOp: (op: RBinaryOp<Info>, lhs: Up, rhs: Up, down: Down) => Up;
+    foldPipe: (op: RPipe<Info>, lhs: Up, rhs: Up, down: Down) => Up;
+    foldUnaryOp: (op: RUnaryOp<Info>, operand: Up, down: Down) => Up;
     loop: {
         foldFor: (loop: RForLoop<Info>, variable: Up, vector: Up, body: Up, down: Down) => Up;
         foldWhile: (loop: RWhileLoop<Info>, condition: Up, body: Up, down: Down) => Up;
@@ -44,11 +55,11 @@ export interface StatefulFoldFunctions<Info, Down, Up> {
     };
     /** The `otherwise` argument is `undefined` if the `else` branch is missing */
     foldIfThenElse: (ifThenExpr: RIfThenElse<Info>, cond: Up, then: Up, otherwise: Up | undefined, down: Down) => Up;
-    foldExprList: (exprList: RExpressionList<Info>, expressions: Up[], down: Down) => Up;
+    foldExprList: (exprList: RExpressionList<Info>, grouping: [start: Up, end: Up] | undefined, expressions: Up[], down: Down) => Up;
     functions: {
         foldFunctionDefinition: (definition: RFunctionDefinition<Info>, params: Up[], body: Up, down: Down) => Up;
         /** folds named and unnamed function calls */
-        foldFunctionCall: (call: RFunctionCall<Info>, functionNameOrExpression: Up, args: (Up | undefined)[], down: Down) => Up;
+        foldFunctionCall: (call: RFunctionCall<Info>, functionNameOrExpression: Up, args: (Up | typeof EmptyArgument)[], down: Down) => Up;
         /** The `name` is `undefined` if the argument is unnamed, the value, if we have something like `x=,...` */
         foldArgument: (argument: RArgument<Info>, name: Up | undefined, value: Up | undefined, down: Down) => Up;
         /** The `defaultValue` is `undefined` if the argument was not initialized with a default value */