npm - @eagleoutice/flowr - Versions diffs - 2.0.25 → 2.1.0 - Mend

@eagleoutice/flowr 2.0.25 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (381) hide show

package/r-bridge/lang-4.x/ast/model/nodes/r-while-loop.d.ts CHANGED Viewed

@@ -2,8 +2,8 @@ import type { Base, Location, NoInfo, RNode } from '../model';
 import type { RType } from '../type';
 import type { RExpressionList } from './r-expression-list';
 /**
- * ```ts
- * while ( <condition> ) <body>
+ * ```r
+ * while(<condition>) <body>
  * ```
  */
 export interface RWhileLoop<Info = NoInfo> extends Base<Info>, Location {

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

@@ -1,48 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnaryOperatorsInRAst = exports.OperatorsInRAst = exports.Operators = exports.OperatorDatabase = void 0;
+const type_1 = require("./type");
 /* eslint-disable */
 exports.OperatorDatabase = {
     /* model formulae */
-    '~': { name: 'model formulae', stringUsedInRAst: "~" /* RawRType.Tilde */, stringUsedInternally: '~', writtenAs: 'infix', arity: 3 /* OperatorArity.Both */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'model-formula', 'function-calls'] },
+    '~': { name: 'model formulae', stringUsedInRAst: type_1.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: '+', 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'] },
+    '+': { name: 'addition or unary +', stringUsedInRAst: type_1.RawRType.Plus, stringUsedInternally: '+', writtenAs: 'infix', arity: 3 /* OperatorArity.Both */, usedAs: 'operation', capabilities: ['function-calls'] },
+    '-': { name: 'subtraction or unary -', stringUsedInRAst: type_1.RawRType.Minus, stringUsedInternally: '-', writtenAs: 'infix', arity: 3 /* OperatorArity.Both */, usedAs: 'operation', capabilities: ['function-calls'] },
+    '*': { name: 'multiplication', stringUsedInRAst: type_1.RawRType.Times, stringUsedInternally: '*', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '/': { name: 'division', stringUsedInRAst: type_1.RawRType.Div, stringUsedInternally: '/', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '^': { name: 'exponentiation', stringUsedInRAst: type_1.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: '**', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '**': { name: 'alternative exponentiation', stringUsedInRAst: type_1.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: '==', 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'] },
+    '==': { name: 'equal to', stringUsedInRAst: type_1.RawRType.Eq, stringUsedInternally: '==', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '!=': { name: 'not equal to', stringUsedInRAst: type_1.RawRType.Ne, stringUsedInternally: '!=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '>': { name: 'greater than', stringUsedInRAst: type_1.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: type_1.RawRType.Ge, stringUsedInternally: '>=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '<': { name: 'less than', stringUsedInRAst: type_1.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: type_1.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: '&', 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'] },
+    '&': { name: 'logical and (vectorized)', stringUsedInRAst: type_1.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: type_1.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: type_1.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: type_1.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: type_1.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: '<-', 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-table-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'] },
+    '<-': { name: 'left assignment', stringUsedInRAst: type_1.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: type_1.RawRType.LeftAssign, stringUsedInternally: ':=', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'assignment', capabilities: ['binary-operator', 'infix-calls', 'assignment-functions', 'local-table-assignment', 'function-calls'] },
+    '<<-': { name: 'left global assignment', stringUsedInRAst: type_1.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: type_1.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: type_1.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: type_1.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: ':', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
-    '?': { name: 'question', stringUsedInRAst: "?" /* RawRType.Question */, stringUsedInternally: '?', writtenAs: 'prefix', arity: 1 /* OperatorArity.Unary */, usedAs: 'operation', capabilities: ['unary-operator', 'built-in-help'] }
+    ':': { name: 'sequence operator', stringUsedInRAst: type_1.RawRType.Colon, stringUsedInternally: ':', writtenAs: 'infix', arity: 2 /* OperatorArity.Binary */, usedAs: 'operation', capabilities: ['binary-operator', 'infix-calls', 'function-calls'] },
+    '?': { name: 'question', stringUsedInRAst: type_1.RawRType.Question, stringUsedInternally: '?', writtenAs: 'prefix', arity: 1 /* OperatorArity.Unary */, usedAs: 'operation', capabilities: ['unary-operator', 'built-in-help'] }
 };
 /* eslint-enable */
 function buildOperatorRAstCollection(operators) {

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

@@ -10,9 +10,15 @@
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decorateAst = exports.deterministicLocationIdGenerator = exports.nodeToLocationId = exports.sourcedDeterministicCountingIdGenerator = exports.deterministicPrefixIdGenerator = exports.deterministicCountingIdGenerator = void 0;
+exports.deterministicCountingIdGenerator = deterministicCountingIdGenerator;
+exports.deterministicPrefixIdGenerator = deterministicPrefixIdGenerator;
+exports.sourcedDeterministicCountingIdGenerator = sourcedDeterministicCountingIdGenerator;
+exports.nodeToLocationId = nodeToLocationId;
+exports.deterministicLocationIdGenerator = deterministicLocationIdGenerator;
+exports.decorateAst = decorateAst;
 const assert_1 = require("../../../../../util/assert");
 const bimap_1 = require("../../../../../util/bimap");
+const type_1 = require("../type");
 const stateful_fold_1 = require("./stateful-fold");
 const r_function_call_1 = require("../nodes/r-function-call");
 /**
@@ -21,16 +27,13 @@ const r_function_call_1 = require("../nodes/r-function-call");
 function deterministicCountingIdGenerator(id = 0) {
     return () => id++;
 }
-exports.deterministicCountingIdGenerator = deterministicCountingIdGenerator;
 function deterministicPrefixIdGenerator(prefix, id = 0) {
     return () => `${prefix}-${id++}`;
 }
-exports.deterministicPrefixIdGenerator = deterministicPrefixIdGenerator;
 function sourcedDeterministicCountingIdGenerator(path, location, start = 0) {
     let id = start;
     return () => `${path}-${loc2Id(location)}-${id++}`;
 }
-exports.sourcedDeterministicCountingIdGenerator = sourcedDeterministicCountingIdGenerator;
 function loc2Id([sl, sc, el, ec]) {
     return `${sl}:${sc}-${el}:${ec}`;
 }
@@ -44,7 +47,6 @@ function nodeToLocationId(data) {
     (0, assert_1.guard)(loc !== undefined, 'location must be defined to generate a location id');
     return loc2Id(loc);
 }
-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.
@@ -55,13 +57,12 @@ 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 nestForElement = new Set([
-    "RFunctionDefinition" /* RType.FunctionDefinition */, "RForLoop" /* RType.ForLoop */, "RWhileLoop" /* RType.WhileLoop */, "RRepeatLoop" /* RType.RepeatLoop */, "RIfThenElse" /* RType.IfThenElse */,
+    type_1.RType.FunctionDefinition, type_1.RType.ForLoop, type_1.RType.WhileLoop, type_1.RType.RepeatLoop, type_1.RType.IfThenElse,
 ]);
 /**
  * Covert the given AST into a doubly linked tree while assigning ids (so it stays serializable).
@@ -125,7 +126,6 @@ function decorateAst(ast, getId = deterministicCountingIdGenerator(0)) {
         idMap
     };
 }
-exports.decorateAst = decorateAst;
 function createFoldForLeaf(info) {
     return (data, nesting) => {
         const id = info.getId(data);
@@ -153,7 +153,7 @@ function createFoldForBinaryOp(info) {
         const rhsInfo = rhs.info;
         rhsInfo.parent = id;
         rhsInfo.index = 1;
-        if (data.type === "RPipe" /* RType.Pipe */) {
+        if (data.type === type_1.RType.Pipe) {
             lhsInfo.role = "pipe-lhs" /* RoleInParent.PipeLhs */;
             rhsInfo.role = "pipe-rhs" /* RoleInParent.PipeRhs */;
         }

package/r-bridge/lang-4.x/ast/model/processing/fold.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.foldAst = void 0;
+exports.foldAst = foldAst;
 const stateful_fold_1 = require("./stateful-fold");
 const down = () => undefined;
 /**
@@ -16,5 +16,4 @@ function foldAst(ast, folds) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
     return (0, stateful_fold_1.foldAstStateful)(ast, undefined, statefulFolds);
 }
-exports.foldAst = foldAst;
 //# sourceMappingURL=fold.js.map

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

@@ -1,8 +1,13 @@
 import type { AstIdMap } from './decorate';
+import type { DataflowGraph } from '../../../../../dataflow/graph/graph';
 /** 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;
+/**
+ * Recovers the lexeme of a node from its id in the idmap.
+ */
 export declare function recoverName(id: NodeId, idMap?: AstIdMap): string | undefined;
+export declare function recoverContent(id: NodeId, graph: DataflowGraph): string | undefined;

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

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.recoverName = exports.normalizeIdToNumberIfPossible = void 0;
+exports.normalizeIdToNumberIfPossible = normalizeIdToNumberIfPossible;
+exports.recoverName = recoverName;
+exports.recoverContent = recoverContent;
+const vertex_1 = require("../../../../../dataflow/graph/vertex");
+const retriever_1 = require("../../../../retriever");
 const numIdRegex = /^\d+$/;
 /** used so that we do not have to store strings for the default numeric ids */
 function normalizeIdToNumberIfPossible(id) {
@@ -10,9 +14,28 @@ function normalizeIdToNumberIfPossible(id) {
     }
     return id;
 }
-exports.normalizeIdToNumberIfPossible = normalizeIdToNumberIfPossible;
+/**
+ * Recovers the lexeme of a node from its id in the idmap.
+ */
 function recoverName(id, idMap) {
     return idMap?.get(id)?.lexeme;
 }
-exports.recoverName = recoverName;
+function recoverContent(id, graph) {
+    const vertex = graph.getVertex(id);
+    if (vertex === undefined) {
+        return undefined;
+    }
+    if (vertex.tag === vertex_1.VertexType.FunctionCall && vertex.name) {
+        return vertex.name;
+    }
+    const node = graph.idMap?.get(id);
+    if (node === undefined) {
+        return undefined;
+    }
+    const lexeme = node.lexeme ?? node.info.fullLexeme ?? '';
+    if (vertex.tag === vertex_1.VertexType.Use) {
+        return (0, retriever_1.removeRQuotes)(lexeme);
+    }
+    return lexeme;
+}
 //# sourceMappingURL=node-id.js.map

package/r-bridge/lang-4.x/ast/model/processing/role.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rolesOfParents = void 0;
+exports.rolesOfParents = rolesOfParents;
 /**
  * Returns the roles of the parents of the given node, starting with the parent-role of the node itself.
  */
@@ -13,5 +13,4 @@ function rolesOfParents(node, idMap) {
     }
     return roles;
 }
-exports.rolesOfParents = rolesOfParents;
 //# sourceMappingURL=role.js.map

package/r-bridge/lang-4.x/ast/model/processing/stateful-fold.js CHANGED Viewed

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.foldAstStateful = void 0;
+exports.foldAstStateful = foldAstStateful;
 const assert_1 = require("../../../../../util/assert");
+const type_1 = require("../type");
 const r_function_call_1 = require("../nodes/r-function-call");
 /**
  * Folds in old functional-fashion over the AST structure but allowing for a down function which can pass context to child nodes.
@@ -10,51 +11,50 @@ function foldAstStateful(ast, down, folds) {
     const type = ast.type;
     down = folds.down(ast, down);
     switch (type) {
-        case "RNumber" /* RType.Number */:
+        case type_1.RType.Number:
             return folds.foldNumber(ast, down);
-        case "RString" /* RType.String */:
+        case type_1.RType.String:
             return folds.foldString(ast, down);
-        case "RLogical" /* RType.Logical */:
+        case type_1.RType.Logical:
             return folds.foldLogical(ast, down);
-        case "RSymbol" /* RType.Symbol */:
+        case type_1.RType.Symbol:
             return folds.foldSymbol(ast, down);
-        case "RComment" /* RType.Comment */:
+        case type_1.RType.Comment:
             return folds.other.foldComment(ast, down);
-        case "RLineDirective" /* RType.LineDirective */:
+        case type_1.RType.LineDirective:
             return folds.other.foldLineDirective(ast, down);
-        case "RPipe" /* RType.Pipe */:
+        case type_1.RType.Pipe:
             return folds.foldPipe(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
-        case "RBinaryOp" /* RType.BinaryOp */:
+        case type_1.RType.BinaryOp:
             return folds.foldBinaryOp(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
-        case "RUnaryOp" /* RType.UnaryOp */:
+        case type_1.RType.UnaryOp:
             return folds.foldUnaryOp(ast, foldAstStateful(ast.operand, down, folds), down);
-        case "RAccess" /* RType.Access */:
+        case type_1.RType.Access:
             return folds.foldAccess(ast, foldAstStateful(ast.accessed, down, folds), ast.access.map(access => access === r_function_call_1.EmptyArgument ? r_function_call_1.EmptyArgument : foldAstStateful(access, down, folds)), down);
-        case "RForLoop" /* RType.ForLoop */:
+        case type_1.RType.ForLoop:
             return folds.loop.foldFor(ast, foldAstStateful(ast.variable, down, folds), foldAstStateful(ast.vector, down, folds), foldAstStateful(ast.body, down, folds), down);
-        case "RWhileLoop" /* RType.WhileLoop */:
+        case type_1.RType.WhileLoop:
             return folds.loop.foldWhile(ast, foldAstStateful(ast.condition, down, folds), foldAstStateful(ast.body, down, folds), down);
-        case "RRepeatLoop" /* RType.RepeatLoop */:
+        case type_1.RType.RepeatLoop:
             return folds.loop.foldRepeat(ast, foldAstStateful(ast.body, down, folds), down);
-        case "RFunctionCall" /* RType.FunctionCall */:
+        case type_1.RType.FunctionCall:
             return folds.functions.foldFunctionCall(ast, foldAstStateful(ast.named ? ast.functionName : ast.calledFunction, down, folds), ast.arguments.map(param => param === r_function_call_1.EmptyArgument ? param : foldAstStateful(param, down, folds)), down);
-        case "RFunctionDefinition" /* RType.FunctionDefinition */:
+        case type_1.RType.FunctionDefinition:
             return folds.functions.foldFunctionDefinition(ast, ast.parameters.map(param => foldAstStateful(param, down, folds)), foldAstStateful(ast.body, down, folds), down);
-        case "RParameter" /* RType.Parameter */:
+        case type_1.RType.Parameter:
             return folds.functions.foldParameter(ast, foldAstStateful(ast.name, down, folds), ast.defaultValue ? foldAstStateful(ast.defaultValue, down, folds) : undefined, down);
-        case "RArgument" /* RType.Argument */:
+        case type_1.RType.Argument:
             return folds.functions.foldArgument(ast, ast.name ? foldAstStateful(ast.name, down, folds) : undefined, ast.value ? foldAstStateful(ast.value, down, folds) : undefined, down);
-        case "RNext" /* RType.Next */:
+        case type_1.RType.Next:
             return folds.loop.foldNext(ast, down);
-        case "RBreak" /* RType.Break */:
+        case type_1.RType.Break:
             return folds.loop.foldBreak(ast, down);
-        case "RIfThenElse" /* RType.IfThenElse */:
+        case type_1.RType.IfThenElse:
             return folds.foldIfThenElse(ast, foldAstStateful(ast.condition, down, folds), foldAstStateful(ast.then, down, folds), ast.otherwise === undefined ? undefined : foldAstStateful(ast.otherwise, down, folds), down);
-        case "RExpressionList" /* RType.ExpressionList */:
+        case type_1.RType.ExpressionList:
             return folds.foldExprList(ast, ast.grouping ? [foldAstStateful(ast.grouping[0], down, folds), foldAstStateful(ast.grouping[1], down, folds)] : undefined, ast.children.map(expr => foldAstStateful(expr, down, folds)), down);
         default:
             (0, assert_1.assertUnreachable)(type);
     }
 }
-exports.foldAstStateful = foldAstStateful;
 //# sourceMappingURL=stateful-fold.js.map

package/r-bridge/lang-4.x/ast/model/processing/visitor.js CHANGED Viewed

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.visitAst = void 0;
+exports.visitAst = visitAst;
+const type_1 = require("../type");
 const assert_1 = require("../../../../../util/assert");
 const r_function_call_1 = require("../nodes/r-function-call");
 // capsuled as a class to avoid passing onExit and onEnter on *each* visit call
@@ -18,65 +19,65 @@ class NodeVisitor {
         /* let the type system know that the type does not change */
         const type = node.type;
         switch (type) {
-            case "RFunctionCall" /* RType.FunctionCall */:
+            case type_1.RType.FunctionCall:
                 this.visitSingle(node.named ? node.functionName : node.calledFunction);
                 this.visit(node.arguments);
                 break;
-            case "RFunctionDefinition" /* RType.FunctionDefinition */:
+            case type_1.RType.FunctionDefinition:
                 this.visit(node.parameters);
                 this.visitSingle(node.body);
                 break;
-            case "RExpressionList" /* RType.ExpressionList */:
+            case type_1.RType.ExpressionList:
                 this.visit(node.grouping);
                 this.visit(node.children);
                 break;
-            case "RForLoop" /* RType.ForLoop */:
+            case type_1.RType.ForLoop:
                 this.visitSingle(node.variable);
                 this.visitSingle(node.vector);
                 this.visitSingle(node.body);
                 break;
-            case "RWhileLoop" /* RType.WhileLoop */:
+            case type_1.RType.WhileLoop:
                 this.visitSingle(node.condition);
                 this.visitSingle(node.body);
                 break;
-            case "RRepeatLoop" /* RType.RepeatLoop */:
+            case type_1.RType.RepeatLoop:
                 this.visitSingle(node.body);
                 break;
-            case "RIfThenElse" /* RType.IfThenElse */:
+            case type_1.RType.IfThenElse:
                 this.visitSingle(node.condition);
                 this.visitSingle(node.then);
                 this.visit(node.otherwise);
                 break;
-            case "RBinaryOp" /* RType.BinaryOp */:
-            case "RPipe" /* RType.Pipe */:
+            case type_1.RType.BinaryOp:
+            case type_1.RType.Pipe:
                 this.visitSingle(node.lhs);
                 this.visitSingle(node.rhs);
                 break;
-            case "RUnaryOp" /* RType.UnaryOp */:
+            case type_1.RType.UnaryOp:
                 this.visitSingle(node.operand);
                 break;
-            case "RParameter" /* RType.Parameter */:
+            case type_1.RType.Parameter:
                 this.visitSingle(node.name);
                 this.visit(node.defaultValue);
                 break;
-            case "RArgument" /* RType.Argument */:
+            case type_1.RType.Argument:
                 this.visit(node.name);
                 this.visit(node.value);
                 break;
-            case "RAccess" /* RType.Access */:
+            case type_1.RType.Access:
                 this.visitSingle(node.accessed);
                 if (node.operator === '[' || node.operator === '[[') {
                     this.visit(node.access);
                 }
                 break;
-            case "RSymbol" /* RType.Symbol */:
-            case "RLogical" /* RType.Logical */:
-            case "RNumber" /* RType.Number */:
-            case "RString" /* RType.String */:
-            case "RComment" /* RType.Comment */:
-            case "RBreak" /* RType.Break */:
-            case "RNext" /* RType.Next */:
-            case "RLineDirective" /* RType.LineDirective */:
+            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:
                 // leafs
                 break;
             default:
@@ -108,5 +109,4 @@ class NodeVisitor {
 function visitAst(nodes, onVisit, onExit) {
     return new NodeVisitor(onVisit, onExit).visit(nodes);
 }
-exports.visitAst = visitAst;
 //# sourceMappingURL=visitor.js.map

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

@@ -5,7 +5,7 @@
  *
  * @see RType
  */
-export declare const enum RawRType {
+export declare enum RawRType {
     /** T1 */
     NullConst = "NULL_CONST",
     /** T2 */
@@ -155,7 +155,7 @@ export declare const enum RawRType {
  *
  * @see RawRType
  */
-export declare const enum RType {
+export declare enum RType {
     /** {@link RAccess} */
     Access = "RAccess",
     /** {@link RArgument} */