@eagleoutice/flowr 2.9.9 → 2.9.11

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

@@ -4,8 +4,45 @@ import type { DataflowGraph } from '../../../../../dataflow/graph/graph';
 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;
+/**
+ * A variant of {@link NodeId} that represents built-in functions or operators. The string is prefixed with `built-in:` to avoid confusion with other node ids.
+ */
+export type BuiltIn<T extends string = string> = `built-in:${T}`;
+/**
+ * The type of the id assigned to each node. Branded to avoid problematic usages with other string or numeric types.
+ * The default ids are numeric, but we use a branded type to avoid confusion with other numeric types.
+ * Custom ids or scoped ids can be strings, but they will be normalized to numbers if they are numeric strings.
+ */
+export declare const NodeId: {
+    readonly name: "NodeId";
+    /**
+     * Normalizes a node id by converting numeric strings to numbers.
+     * This allows us to use numeric ids without storing them as strings, while still allowing custom string ids if needed.
+     */
+    readonly normalize: (this: void, id: NodeId) => NodeId;
+    /**
+     * The prefix used for built-in function or operator ids.
+     */
+    readonly builtInPrefix: "built-in:";
+    /**
+     * Checks if a given node id is a built-in function or operator id by checking if it is a string that starts with the built-in prefix.
+     * @see {@link toBuiltIn} - to convert a built-in function or operator name to a built-in id
+     * @see {@link fromBuiltIn} - to recover the built-in function or operator name from a built-in id
+     */
+    readonly isBuiltIn: (this: void, id: BuiltIn | NodeId | undefined) => id is BuiltIn;
+    /**
+     * Converts a built-in function or operator name to a built-in id by prefixing it with the built-in prefix.
+     * @see {@link isBuiltIn} - to check if a given node id is a built-in function or operator id
+     * @see {@link fromBuiltIn} - to recover the built-in function or operator name from a built-in id
+     */
+    readonly toBuiltIn: <T extends string>(this: void, name: T) => BuiltIn<T>;
+    /**
+     * Recovers the built-in function or operator name from a built-in id by removing the built-in prefix.
+     * @see {@link isBuiltIn} - to check if a given node id is a built-in function or operator id
+     * @see {@link toBuiltIn} - to convert a built-in function or operator name to a built-in id
+     */
+    readonly fromBuiltIn: <T extends string>(this: void, id: BuiltIn<T>) => T;
+};
 /**
  * Recovers the lexeme of a {@link RNode|node} from its id in the {@link AstIdMap|id map}.
  * @see {@link recoverContent} - to recover the content of a node

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

@@ -1,20 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeIdToNumberIfPossible = normalizeIdToNumberIfPossible;
+exports.NodeId = void 0;
 exports.recoverName = recoverName;
 exports.recoverContent = recoverContent;
 const vertex_1 = require("../../../../../dataflow/graph/vertex");
 const retriever_1 = require("../../../../retriever");
 const identifier_1 = require("../../../../../dataflow/environments/identifier");
-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);
+/**
+ * The type of the id assigned to each node. Branded to avoid problematic usages with other string or numeric types.
+ * The default ids are numeric, but we use a branded type to avoid confusion with other numeric types.
+ * Custom ids or scoped ids can be strings, but they will be normalized to numbers if they are numeric strings.
+ */
+exports.NodeId = {
+    name: 'NodeId',
+    /**
+     * Normalizes a node id by converting numeric strings to numbers.
+     * This allows us to use numeric ids without storing them as strings, while still allowing custom string ids if needed.
+     */
+    normalize(id) {
+        // check if string is number
+        if (typeof id === 'string') {
+            /* typescript is a beautiful converter */
+            const num = +id;
+            if (!Number.isNaN(num)) {
+                return num;
+            }
+        }
+        return id;
+    },
+    /**
+     * The prefix used for built-in function or operator ids.
+     */
+    builtInPrefix: 'built-in:',
+    /**
+     * Checks if a given node id is a built-in function or operator id by checking if it is a string that starts with the built-in prefix.
+     * @see {@link toBuiltIn} - to convert a built-in function or operator name to a built-in id
+     * @see {@link fromBuiltIn} - to recover the built-in function or operator name from a built-in id
+     */
+    isBuiltIn(id) {
+        return typeof id === 'string' && id.startsWith(exports.NodeId.builtInPrefix);
+    },
+    /**
+     * Converts a built-in function or operator name to a built-in id by prefixing it with the built-in prefix.
+     * @see {@link isBuiltIn} - to check if a given node id is a built-in function or operator id
+     * @see {@link fromBuiltIn} - to recover the built-in function or operator name from a built-in id
+     */
+    toBuiltIn(name) {
+        return `built-in:${name}`;
+    },
+    /**
+     * Recovers the built-in function or operator name from a built-in id by removing the built-in prefix.
+     * @see {@link isBuiltIn} - to check if a given node id is a built-in function or operator id
+     * @see {@link toBuiltIn} - to convert a built-in function or operator name to a built-in id
+     */
+    fromBuiltIn(id) {
+        return id.slice(builtInPrefixLength);
     }
-    return id;
-}
+};
+const builtInPrefixLength = exports.NodeId.builtInPrefix.length;
 /**
  * Recovers the lexeme of a {@link RNode|node} from its id in the {@link AstIdMap|id map}.
  * @see {@link recoverContent} - to recover the content of a node

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

@@ -8,31 +8,32 @@ import type { AstIdMap, RNodeWithParent } from './decorate';
 export declare const enum RoleInParent {
     /** has no parent */
     Root = "root",
-    IfCondition = "if-cond",
+    IfCondition = "if-c",
     IfThen = "if-then",
     IfOtherwise = "if-other",
-    WhileCondition = "while-cond",
-    WhileBody = "while-body",
-    RepeatBody = "repeat-body",
+    WhileCondition = "while-c",
+    WhileBody = "while-b",
+    RepeatBody = "repeat-b",
     ForVariable = "for-var",
     ForVector = "for-vec",
-    ForBody = "for-body",
+    ForBody = "for-b",
     FunctionCallName = "call-name",
     FunctionCallArgument = "call-arg",
-    FunctionDefinitionBody = "fun-body",
+    FunctionDefinitionBody = "fun-b",
     FunctionDefinitionParameter = "param",
-    ExpressionListChild = "expr-list-child",
-    BinaryOperationLhs = "binop-lhs",
-    BinaryOperationRhs = "binop-rhs",
-    PipeLhs = "pipe-lhs",
-    PipeRhs = "pipe-rhs",
+    ExpressionListChild = "el-c",
+    ExpressionListGrouping = "el-g",
+    BinaryOperationLhs = "bin-l",
+    BinaryOperationRhs = "bin-r",
+    PipeLhs = "pipe-l",
+    PipeRhs = "pipe-r",
     UnaryOperand = "unary-op",
-    ParameterName = "param-name",
-    ParameterDefaultValue = "param-value",
-    ArgumentName = "arg-name",
-    ArgumentValue = "arg-value",
-    Accessed = "accessed",
-    IndexAccess = "index-acc"
+    ParameterName = "param-n",
+    ParameterDefaultValue = "param-v",
+    ArgumentName = "arg-n",
+    ArgumentValue = "arg-v",
+    Accessed = "acc",
+    IndexAccess = "idx-acc"
 }
 /**
  * Returns the roles of the parents of the given node, starting with the parent-role of the node itself.

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

@@ -1,12 +1,13 @@
 import type { NoInfo, RNode } from '../model';
+import type { EmptyArgument } from '../nodes/r-function-call';
 /** Return `true` to stop visiting from this node (i.e., do not continue to visit this node *and* the children) */
 export type OnEnter<OtherInfo> = (node: RNode<OtherInfo>) => (boolean | void);
 /** Similar to {@link OnEnter} but called when leaving a node. Can't stop exploration as the subtree is already visited! */
 export type OnExit<OtherInfo> = (node: RNode<OtherInfo>) => void;
-/**
- * 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)
- */
-export declare function visitAst<OtherInfo = NoInfo>(nodes: RNode<OtherInfo> | (RNode<OtherInfo> | null | undefined)[] | undefined, onVisit?: OnEnter<OtherInfo>, onExit?: OnExit<OtherInfo>): void;
+export declare class NodeVisitor<OtherInfo = NoInfo> {
+    private readonly onEnter?;
+    private readonly onExit?;
+    constructor(onEnter?: OnEnter<OtherInfo>, onExit?: OnExit<OtherInfo>);
+    private visitSingle;
+    visit(nodes: RNode<OtherInfo> | readonly (RNode<OtherInfo> | null | undefined | typeof EmptyArgument)[] | undefined | null): void;
+}

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

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.visitAst = visitAst;
+exports.NodeVisitor = void 0;
 const type_1 = require("../type");
 const assert_1 = require("../../../../../util/assert");
-const r_function_call_1 = require("../nodes/r-function-call");
+const r_access_1 = require("../nodes/r-access");
+const graph_1 = require("../../../../../dataflow/graph/graph");
 // capsuled as a class to avoid passing onExit and onEnter on *each* visit call
 class NodeVisitor {
     onEnter;
@@ -66,7 +67,7 @@ class NodeVisitor {
                 break;
             case type_1.RType.Access:
                 this.visitSingle(node.accessed);
-                if (node.operator === '[' || node.operator === '[[') {
+                if (r_access_1.RAccess.isIndex(node)) {
                     this.visit(node.access);
                 }
                 break;
@@ -89,7 +90,7 @@ class NodeVisitor {
         if (Array.isArray(nodes)) {
             const n = nodes;
             for (const node of n) {
-                if (node && node !== r_function_call_1.EmptyArgument) {
+                if (node && graph_1.FunctionArgument.isNotEmpty(node)) {
                     this.visitSingle(node);
                 }
             }
@@ -99,13 +100,5 @@ class NodeVisitor {
         }
     }
 }
-/**
- * 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)
- */
-function visitAst(nodes, onVisit, onExit) {
-    return new NodeVisitor(onVisit, onExit).visit(nodes);
-}
+exports.NodeVisitor = NodeVisitor;
 //# sourceMappingURL=visitor.js.map

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

@@ -3,7 +3,7 @@ import type { NoInfo } from '../../model/model';
 import type { ParseStepOutput, ParseStepOutputSingleFile } from '../../../../parser';
 import { type FlowrConfigOptions } from '../../../../../config';
 import type { Tree } from 'web-tree-sitter';
-import type { RProject } from '../../model/nodes/r-project';
+import { RProject } from '../../model/nodes/r-project';
 export declare const parseLog: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.

package/r-bridge/lang-4.x/ast/parser/json/parser.js

@@ -18,7 +18,7 @@ exports.parseLog = log_1.log.getSubLogger({ name: 'ast-parser' });
  * @see {@link normalizeTreeSitter}      - for a version that normalizes the AST from the TreeSitter parser
  */
 function normalize(parsed, getId = (0, decorate_1.deterministicCountingIdGenerator)(0)) {
-    return (0, decorate_1.decorateAst)((0, r_project_1.mergeProjects)(parsed.files.map(normalizeButNotDecorated)), { getId });
+    return (0, decorate_1.decorateAst)(r_project_1.RProject.merge(parsed.files.map(normalizeButNotDecorated)), { getId });
 }
 /**
  * Take the output as produced by the parse step and normalize the AST from the R parser.

package/r-bridge/lang-4.x/ast/parser/main/internal/expression/normalize-expression.js

@@ -9,6 +9,8 @@ const normalize_call_1 = require("../functions/normalize-call");
 const normalize_definition_1 = require("../functions/normalize-definition");
 const type_1 = require("../../../../model/type");
 const normalize_comment_1 = require("../other/normalize-comment");
+const r_delimiter_1 = require("../../../../model/nodes/info/r-delimiter");
+const r_comment_1 = require("../../../../model/nodes/r-comment");
 /**
  * Returns an expression list if there are multiple children, otherwise returns the single child directly with no expr wrapper
  * @param data - The data used by the parser (see {@link NormalizerData})
@@ -36,10 +38,10 @@ function normalizeExpression(data, entry) {
         return maybeFunctionDefinition;
     }
     const children = (0, normalize_expressions_1.normalizeExpressions)(childData, childrenSource);
-    const [delimiters, nodes] = (0, arrays_1.partition)(children, x => x.type === type_1.RType.Delimiter || x.type === type_1.RType.Comment);
+    const [delimiters, nodes] = (0, arrays_1.partition)(children, x => r_delimiter_1.RDelimiter.is(x) || r_comment_1.RComment.is(x));
     if (nodes.length === 1) {
         const result = nodes[0];
-        result.info.adToks = [...result.info.adToks ?? [], ...delimiters];
+        result.info.adToks = result.info.adToks ? result.info.adToks.concat(delimiters) : delimiters.slice();
         return result;
     }
     else {

package/r-bridge/lang-4.x/ast/parser/main/internal/values/normalize-number.js

@@ -41,7 +41,7 @@ function normalizeNumber(data, obj) {
         return {
             ...common,
             type: type_1.RType.Number,
-            content: (0, convert_values_1.number2ts)(content)
+            content: convert_values_1.RNumberValue.fromRLexeme(content)
         };
     }
 }

package/r-bridge/lang-4.x/ast/parser/main/internal/values/normalize-string.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeString = normalizeString;
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
-const convert_values_1 = require("../../../../../convert-values");
 const type_1 = require("../../../../model/type");
+const convert_values_1 = require("../../../../../convert-values");
 /**
  * Normalize the given object as a R string (see {@link string2ts}).
  * This requires you to check the corresponding name beforehand.
@@ -23,7 +23,7 @@ function normalizeString(data, obj) {
     return {
         type: type_1.RType.String,
         location,
-        content: (0, convert_values_1.string2ts)(stringContent),
+        content: convert_values_1.RStringValue.fromRLexeme(stringContent),
         lexeme: stringContent,
         info: {
             fullRange: data.currentRange,

package/r-bridge/lang-4.x/convert-values.d.ts

@@ -30,10 +30,13 @@ export interface RNumberValue {
     /** see {@link RImaginaryMarker}, compound imaginary numbers are expressions in R */
     complexNumber: boolean;
 }
+export declare const RNumberValue: {
+    readonly name: "RNumberValue";
+    readonly fromRLexeme: (this: void, value: string) => RNumberValue;
+};
 /**
- * Convert a valid R number into a {@link RNumberValue}.
+ * Represents a string value in R, including the type of quotes used and whether it is a raw string.
  */
-export declare function number2ts(value: string): RNumberValue;
 export interface RStringValue {
     str: string;
     /** from the R-language definition a string is either delimited by a pair of single or double quotes, 'none' strings are syntactically unquoted but treated as strings  */
@@ -42,10 +45,16 @@ export interface RStringValue {
     flag?: 'raw';
 }
 /**
- * Convert a valid R string into a {@link RStringValue}.
- * @throws {@link ValueConversionError} if the string has an unknown starting quote
+ * Checks whether the given string is an R string literal (including raw strings).
  */
-export declare function string2ts(value: string): RStringValue;
+export declare const RStringValue: {
+    readonly name: "RStringValue";
+    /**
+     * Convert a valid R string into a {@link RStringValue}.
+     * @throws {@link ValueConversionError} if the string has an unknown starting quote
+     */
+    readonly fromRLexeme: (this: void, value: string) => RStringValue;
+};
 export declare const RNa = "NA";
 export declare const RNull = "NULL";
 /**

package/r-bridge/lang-4.x/convert-values.js

@@ -1,11 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RNull = exports.RNa = exports.RInf = exports.RIntegerMarker = exports.RImaginaryMarker = exports.RNumHexFloatRegex = exports.RFalse = exports.RTrue = void 0;
+exports.RNull = exports.RNa = exports.RStringValue = exports.RNumberValue = exports.RInf = exports.RIntegerMarker = exports.RImaginaryMarker = exports.RNumHexFloatRegex = exports.RFalse = exports.RTrue = void 0;
 exports.ts2r = ts2r;
 exports.isBoolean = isBoolean;
 exports.boolean2ts = boolean2ts;
-exports.number2ts = number2ts;
-exports.string2ts = string2ts;
 exports.isNA = isNA;
 const strings_1 = require("../../util/text/strings");
 class ValueConversionError extends Error {
@@ -79,85 +77,91 @@ function getDecimalPlacesWithRadix(floatPart, radix) {
 exports.RImaginaryMarker = 'i';
 exports.RIntegerMarker = 'L';
 exports.RInf = 'Inf';
-/**
- * Convert a valid R number into a {@link RNumberValue}.
- */
-function number2ts(value) {
-    // check for hexadecimal number with floating point addon which is supported by R but not by JS :/
-    let lcValue = value.toLowerCase();
-    /* both checks are case-sensitive! */
-    const last = value.at(-1);
-    const markedAsInt = last === exports.RIntegerMarker;
-    const complexNumber = last === exports.RImaginaryMarker;
-    if (markedAsInt || complexNumber) {
-        lcValue = lcValue.slice(0, -1);
-    }
-    if (value === exports.RInf) {
-        return {
-            num: Infinity,
-            complexNumber,
-            markedAsInt
-        };
-    }
-    if (value === exports.RNa) {
-        return {
-            num: NaN,
-            complexNumber,
-            markedAsInt
-        };
-    }
-    const floatHex = lcValue.match(exports.RNumHexFloatRegex);
-    if (floatHex == null) {
-        return {
-            num: Number(lcValue),
-            complexNumber,
-            markedAsInt
-        };
-    }
-    else {
-        const { intPart, floatPart, exp } = floatHex.groups;
-        const base = intPart === undefined ? 0 : parseInt(`${intPart}`, 16);
-        const floatSuffix = floatPart === undefined ? 0 : getDecimalPlacesWithRadix(floatPart, 16);
-        const exponent = parseInt(exp, 10);
-        return {
-            num: (base + floatSuffix) * Math.pow(2, exponent),
-            complexNumber,
-            markedAsInt
-        };
+exports.RNumberValue = {
+    name: 'RNumberValue',
+    fromRLexeme(value) {
+        // check for hexadecimal number with floating point addon which is supported by R but not by JS :/
+        let lcValue = value.toLowerCase();
+        /* both checks are case-sensitive! */
+        const last = value.at(-1);
+        const markedAsInt = last === exports.RIntegerMarker;
+        const complexNumber = last === exports.RImaginaryMarker;
+        if (markedAsInt || complexNumber) {
+            lcValue = lcValue.slice(0, -1);
+        }
+        if (value === exports.RInf) {
+            return {
+                num: Infinity,
+                complexNumber,
+                markedAsInt
+            };
+        }
+        if (value === exports.RNa) {
+            return {
+                num: NaN,
+                complexNumber,
+                markedAsInt
+            };
+        }
+        const floatHex = lcValue.match(exports.RNumHexFloatRegex);
+        if (floatHex == null) {
+            return {
+                num: Number(lcValue),
+                complexNumber,
+                markedAsInt
+            };
+        }
+        else {
+            const { intPart, floatPart, exp } = floatHex.groups;
+            const base = intPart === undefined ? 0 : parseInt(`${intPart}`, 16);
+            const floatSuffix = floatPart === undefined ? 0 : getDecimalPlacesWithRadix(floatPart, 16);
+            const exponent = parseInt(exp, 10);
+            return {
+                num: (base + floatSuffix) * Math.pow(2, exponent),
+                complexNumber,
+                markedAsInt
+            };
+        }
     }
-}
+};
 /**
- * Convert a valid R string into a {@link RStringValue}.
- * @throws {@link ValueConversionError} if the string has an unknown starting quote
+ * Checks whether the given string is an R string literal (including raw strings).
  */
-function string2ts(value) {
-    if (value.length < 2) {
-        throw new ValueConversionError(`cannot parse string '${value}' as it is too short`);
-    }
-    const init = value[0];
-    if (init === '"' || init === '\'') {
-        return {
-            str: value.slice(1, -1),
-            quotes: init
-        };
-    }
-    else if (init === 'r' || init === 'R' && value.length >= 3) {
-        const flags = value[1];
-        if (flags === '"' || flags === '\'') {
+exports.RStringValue = {
+    name: 'RStringValue',
+    /**
+     * Convert a valid R string into a {@link RStringValue}.
+     * @throws {@link ValueConversionError} if the string has an unknown starting quote
+     */
+    fromRLexeme(value) {
+        if (value.length < 2) {
+            throw new ValueConversionError(`cannot parse string '${value}' as it is too short`);
+        }
+        const init = value[0];
+        if (init === '"' || init === '\'') {
             return {
-                str: (0, strings_1.dropRawStringSurround)(value.slice(2, -1)),
-                quotes: flags,
-                flag: 'raw'
+                str: value.slice(1, -1),
+                quotes: init
             };
         }
+        else if ((init === 'r' || init === 'R') && value.length >= 3) {
+            const flags = value[1];
+            if (flags === '"' || flags === '\'') {
+                return {
+                    str: (0, strings_1.dropRawStringSurround)(value.slice(2, -1)),
+                    quotes: flags,
+                    flag: 'raw'
+                };
+            }
+            else {
+                throw new ValueConversionError(`expected string to start with a known quote (' or "), or raw, yet received ${value}`);
+            }
+        }
         else {
             throw new ValueConversionError(`expected string to start with a known quote (' or "), or raw, yet received ${value}`);
         }
     }
-    else {
-        throw new ValueConversionError(`expected string to start with a known quote (' or "), or raw, yet received ${value}`);
-    }
-}
+};
 exports.RNa = 'NA';
 exports.RNull = 'NULL';
 /**