@eagleoutice/flowr 2.0.25 → 2.1.0

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

@@ -1,17 +1,227 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSymbol = void 0;
+exports.RType = exports.RawRType = void 0;
+exports.isSymbol = isSymbol;
+/**
+ * Token types as they are produced by the R parser.
+ * Not all of them are directly handled by the normalize step.
+ * Some of them are also listed as part of the {@link OperatorDatabase}.
+ *
+ * @see RType
+ */
+var RawRType;
+(function (RawRType) {
+    /** T1 */
+    RawRType["NullConst"] = "NULL_CONST";
+    /** T2 */
+    RawRType["NumericConst"] = "NUM_CONST";
+    /** T3 */
+    RawRType["StringConst"] = "STR_CONST";
+    /** T4 */
+    RawRType["EqualAssign"] = "EQ_ASSIGN";
+    /** T5 */
+    RawRType["EqualFormals"] = "EQ_FORMALS";
+    /** T6 */
+    RawRType["EqualSub"] = "EQ_SUB";
+    /** T7 */
+    RawRType["LeftAssign"] = "LEFT_ASSIGN";
+    /** T8 */
+    RawRType["RightAssign"] = "RIGHT_ASSIGN";
+    /** T9 */
+    RawRType["And"] = "AND";
+    /** T10 */
+    RawRType["And2"] = "AND2";
+    /** T11 */
+    RawRType["Eq"] = "EQ";
+    /** T12 */
+    RawRType["Ge"] = "GE";
+    /** T13 */
+    RawRType["Gt"] = "GT";
+    /** T14 */
+    RawRType["Le"] = "LE";
+    /** T15 */
+    RawRType["Lt"] = "LT";
+    /** T16 */
+    RawRType["Ne"] = "NE";
+    /** T17 */
+    RawRType["Or"] = "OR";
+    /** T18 */
+    RawRType["Or2"] = "OR2";
+    /** T19 */
+    RawRType["Pipe"] = "PIPE";
+    /** T20 */
+    RawRType["Pipebind"] = "PIPEBIND";
+    /** T21 */
+    RawRType["Special"] = "SPECIAL";
+    /** T22 */
+    RawRType["Plus"] = "+";
+    /** T23 */
+    RawRType["Minus"] = "-";
+    /** T24 */
+    RawRType["Times"] = "*";
+    /** T25 */
+    RawRType["Div"] = "/";
+    /** T26 */
+    RawRType["Colon"] = ":";
+    /** T27 */
+    RawRType["Exclamation"] = "!";
+    /** T28 */
+    RawRType["Exp"] = "^";
+    /** T29 */
+    RawRType["Question"] = "?";
+    /** T30 */
+    RawRType["Tilde"] = "~";
+    /** T31 */
+    RawRType["Break"] = "BREAK";
+    /** T32 */
+    RawRType["Else"] = "ELSE";
+    /** T33 */
+    RawRType["For"] = "FOR";
+    /** T34 */
+    RawRType["ForCondition"] = "forcond";
+    /** T35 */
+    RawRType["If"] = "IF";
+    /** T36 */
+    RawRType["ForIn"] = "IN";
+    /** T37 */
+    RawRType["Next"] = "NEXT";
+    /** T38 */
+    RawRType["Repeat"] = "REPEAT";
+    /** T39 */
+    RawRType["While"] = "WHILE";
+    /** T40 */
+    RawRType["Function"] = "FUNCTION";
+    /** T41 */
+    RawRType["Lambda"] = "\\\\";
+    /** T42 */
+    RawRType["DoubleBracketLeft"] = "LBB";
+    /** T43 */
+    RawRType["Slot"] = "SLOT";
+    /** T44 */
+    RawRType["Dollar"] = "$";
+    /** T45 */
+    RawRType["At"] = "@";
+    /** T46 */
+    RawRType["BracketLeft"] = "[";
+    /** T47 */
+    RawRType["BracketRight"] = "]";
+    /** T48 */
+    RawRType["NsGet"] = "::";
+    /** T49 */
+    RawRType["NsGetInt"] = ":::";
+    /** T50 */
+    RawRType["Symbol"] = "SYMBOL";
+    /** T51 */
+    RawRType["SymbolFunctionCall"] = "SYMBOL_FUNCTION_CALL";
+    /** T52 */
+    RawRType["SymbolPackage"] = "SYMBOL_PACKAGE";
+    /** T53 */
+    RawRType["SymbolSub"] = "SYMBOL_SUB";
+    /** T54 */
+    RawRType["SymbolFormals"] = "SYMBOL_FORMALS";
+    /** T55 */
+    RawRType["Comment"] = "COMMENT";
+    /** T56 */
+    RawRType["LineDirective"] = "LINE_DIRECTIVE";
+    /** T57 */
+    RawRType["ParenLeft"] = "(";
+    /** T58 */
+    RawRType["ParenRight"] = ")";
+    /** T59 */
+    RawRType["Comma"] = ",";
+    /** T60 */
+    RawRType["Semicolon"] = ";";
+    /** T61 */
+    RawRType["BraceLeft"] = "{";
+    /** T62 */
+    RawRType["BraceRight"] = "}";
+    /** T63 */
+    RawRType["Expression"] = "expr";
+    /** T64
+     *
+     * https://github.com/REditorSupport/languageserver/issues/327
+     * https://github.com/REditorSupport/languageserver/pull/328
+     */
+    RawRType["ExprOfAssignOrHelp"] = "expr_or_assign_or_help";
+    /**
+     * Pre-4.0 version of expr_or_assign_or_help, which was seemingly silently renamed here:
+     * https://github.com/wch/r-source/commit/84bbf385f909c0223924c310af6c7c77aa810234
+     * (Also see {@link ExprOfAssignOrHelp} documentation for more context.)
+     */
+    RawRType["LegacyEqualAssign"] = "equal_assign";
+    /** T65 */
+    RawRType["ExpressionList"] = "exprlist";
+})(RawRType || (exports.RawRType = RawRType = {}));
+/**
+ * Types as we use them for our normalized AST.
+ * See {@link RNode} for a union type of all normalized AST nodes in-use.
+ * For each enum member, the respective normalized AST node should be referenced
+ * in the corresponding comment.
+ *
+ * @see RawRType
+ */
+var RType;
+(function (RType) {
+    /** {@link RAccess} */
+    RType["Access"] = "RAccess";
+    /** {@link RArgument} */
+    RType["Argument"] = "RArgument";
+    /** {@link RBinaryOp} */
+    RType["BinaryOp"] = "RBinaryOp";
+    /** {@link RExpressionList} */
+    RType["ExpressionList"] = "RExpressionList";
+    /** {@link RForLoop} */
+    RType["ForLoop"] = "RForLoop";
+    /** {@link RFunctionCall} */
+    RType["FunctionCall"] = "RFunctionCall";
+    /** {@link RFunctionDefinition} */
+    RType["FunctionDefinition"] = "RFunctionDefinition";
+    /** {@link RIfThenElse} */
+    RType["IfThenElse"] = "RIfThenElse";
+    /** {@link RParameter} */
+    RType["Parameter"] = "RParameter";
+    /** {@link RPipe} */
+    RType["Pipe"] = "RPipe";
+    /** {@link RRepeatLoop} */
+    RType["RepeatLoop"] = "RRepeatLoop";
+    /** {@link RUnaryOp} */
+    RType["UnaryOp"] = "RUnaryOp";
+    /** {@link RWhileLoop} */
+    RType["WhileLoop"] = "RWhileLoop";
+    /** {@link RBreak} */
+    RType["Break"] = "RBreak";
+    /** {@link RComment} */
+    RType["Comment"] = "RComment";
+    /** {@link RLineDirective} */
+    RType["LineDirective"] = "RLineDirective";
+    /** {@link RLogical} */
+    RType["Logical"] = "RLogical";
+    /** {@link RNext} */
+    RType["Next"] = "RNext";
+    /** {@link RNumber} */
+    RType["Number"] = "RNumber";
+    /** {@link RString} */
+    RType["String"] = "RString";
+    /** {@link RSymbol} */
+    RType["Symbol"] = "RSymbol";
+    /* ------ special types ------ */
+    /** {@link RDelimiter}.
+     * Is not part of the normalized AST but can be found in
+     * {@link Source#additionalTokens}.
+     */
+    RType["Delimiter"] = "RDelimiter";
+})(RType || (exports.RType = RType = {}));
 const validSymbolTypes = new Set([
-    "SYMBOL" /* RawRType.Symbol */,
-    "SYMBOL_PACKAGE" /* RawRType.SymbolPackage */,
-    "SYMBOL_FUNCTION_CALL" /* RawRType.SymbolFunctionCall */,
-    "NULL_CONST" /* RawRType.NullConst */,
-    "STR_CONST" /* RawRType.StringConst */,
-    "(" /* RawRType.ParenLeft */,
-    ")" /* RawRType.ParenRight */,
-    "{" /* RawRType.BraceLeft */,
-    "}" /* RawRType.BraceRight */,
-    "SLOT" /* RawRType.Slot */,
+    RawRType.Symbol,
+    RawRType.SymbolPackage,
+    RawRType.SymbolFunctionCall,
+    RawRType.NullConst,
+    RawRType.StringConst,
+    RawRType.ParenLeft,
+    RawRType.ParenRight,
+    RawRType.BraceLeft,
+    RawRType.BraceRight,
+    RawRType.Slot,
 ]);
 /**
  * Validates, whether the given type can be used as a symbol in R
@@ -21,5 +231,4 @@ const validSymbolTypes = new Set([
 function isSymbol(type) {
     return validSymbolTypes.has(type);
 }
-exports.isSymbol = isSymbol;
 //# sourceMappingURL=type.js.map

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareParsedData = exports.RootId = void 0;
+exports.RootId = void 0;
+exports.prepareParsedData = prepareParsedData;
 const retriever_1 = require("../../../../retriever");
 const assert_1 = require("../../../../../util/assert");
 exports.RootId = 0;
@@ -35,5 +36,4 @@ function prepareParsedData(data) {
     }
     return roots;
 }
-exports.prepareParsedData = prepareParsedData;
 //# sourceMappingURL=format.js.map

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

@@ -1,27 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertPreparedParsedData = exports.normalize = exports.parseLog = void 0;
+exports.parseLog = void 0;
+exports.normalize = normalize;
+exports.convertPreparedParsedData = convertPreparedParsedData;
 const format_1 = require("./format");
 const log_1 = require("../../../../../util/log");
 const decorate_1 = require("../../model/processing/decorate");
 const normalize_root_1 = require("../xml/internal/structure/normalize-root");
 const input_format_1 = require("../xml/input-format");
+const type_1 = require("../../model/type");
 exports.parseLog = log_1.log.getSubLogger({ name: 'ast-parser' });
 function normalize(jsonString, getId = (0, decorate_1.deterministicCountingIdGenerator)(0)) {
     const data = { currentRange: undefined, currentLexeme: undefined };
     const object = convertPreparedParsedData((0, format_1.prepareParsedData)(jsonString));
     return (0, decorate_1.decorateAst)((0, normalize_root_1.normalizeRootObjToAst)(data, object), getId);
 }
-exports.normalize = normalize;
 function convertPreparedParsedData(rootEntries) {
     return {
-        ["exprlist" /* RawRType.ExpressionList */]: {
-            [input_format_1.nameKey]: "exprlist" /* RawRType.ExpressionList */,
+        [type_1.RawRType.ExpressionList]: {
+            [input_format_1.nameKey]: type_1.RawRType.ExpressionList,
             [input_format_1.childrenKey]: rootEntries.map(convertEntry)
         }
     };
 }
-exports.convertPreparedParsedData = convertPreparedParsedData;
 function convertEntry(csvEntry) {
     const xmlEntry = {
         [input_format_1.nameKey]: csvEntry.token,

package/r-bridge/lang-4.x/ast/parser/xml/input-format.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getKeysGuarded = exports.getKeyGuarded = exports.XmlParseError = exports.nameKey = exports.contentKey = exports.childrenKey = exports.attributesKey = void 0;
+exports.XmlParseError = exports.nameKey = exports.contentKey = exports.childrenKey = exports.attributesKey = void 0;
+exports.getKeyGuarded = getKeyGuarded;
+exports.getKeysGuarded = getKeysGuarded;
 exports.attributesKey = 'a';
 exports.childrenKey = 'c';
 exports.contentKey = '@';
@@ -24,7 +26,6 @@ function error(key, obj) {
 function getKeyGuarded(obj, key) {
     return (obj[key] ?? error(key, obj));
 }
-exports.getKeyGuarded = getKeyGuarded;
 /**
  * Retrieves the given keys from the converted xml. For a single key, see {@link getKeyGuarded}.
  * Will throw an {@link XmlParseError} if at least one of the keys is not present
@@ -34,5 +35,4 @@ exports.getKeyGuarded = getKeyGuarded;
 function getKeysGuarded(obj, ...keys) {
     return Object.fromEntries(keys.map(k => [k, getKeyGuarded(obj, k)]));
 }
-exports.getKeysGuarded = getKeysGuarded;
 //# sourceMappingURL=input-format.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/control/normalize-if-then-else.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeIfThenElse = void 0;
+exports.tryNormalizeIfThenElse = tryNormalizeIfThenElse;
 const parser_1 = require("../../../json/parser");
 const normalize_if_then_1 = require("./normalize-if-then");
 const assert_1 = require("../../../../../../../util/assert");
 const normalize_meta_1 = require("../../normalize-meta");
 const normalize_single_node_1 = require("../structure/normalize-single-node");
+const type_1 = require("../../../../model/type");
 /**
  * Try to parse the construct as a {@link RIfThenElse}.
  */
@@ -17,13 +18,12 @@ function tryNormalizeIfThenElse(data, tokens) {
         return undefined;
     }
     parser_1.parseLog.trace('if-then part successful, now parsing else part');
-    (0, assert_1.guard)(tokens[5].name === "ELSE" /* RawRType.Else */, () => `expected else token for if-then-else but found ${JSON.stringify(tokens[5])}`);
+    (0, assert_1.guard)(tokens[5].name === type_1.RawRType.Else, () => `expected else token for if-then-else but found ${JSON.stringify(tokens[5])}`);
     const parsedElse = (0, normalize_single_node_1.normalizeSingleNode)(data, tokens[6]);
-    (0, assert_1.guard)(parsedElse.type !== "RDelimiter" /* RType.Delimiter */, () => `unexpected missing else-part of if-then-else, received ${JSON.stringify([parsedIfThen, parsedElse])} for ${JSON.stringify(tokens)}`);
+    (0, assert_1.guard)(parsedElse.type !== type_1.RType.Delimiter, () => `unexpected missing else-part of if-then-else, received ${JSON.stringify([parsedIfThen, parsedElse])} for ${JSON.stringify(tokens)}`);
     return {
         ...parsedIfThen,
         otherwise: (0, normalize_meta_1.ensureExpressionList)(parsedElse)
     };
 }
-exports.tryNormalizeIfThenElse = tryNormalizeIfThenElse;
 //# sourceMappingURL=normalize-if-then-else.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/control/normalize-if-then.js

@@ -1,33 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeIfThen = void 0;
+exports.tryNormalizeIfThen = tryNormalizeIfThen;
 const input_format_1 = require("../../input-format");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
+const type_1 = require("../../../../model/type");
 const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
  * Try to parse the construct as a {@link RIfThenElse}.
  */
 function tryNormalizeIfThen(data, tokens) {
     parser_1.parseLog.trace('trying to parse if-then structure');
-    if (tokens[0].name !== "IF" /* RawRType.If */) {
+    if (tokens[0].name !== type_1.RawRType.If) {
         parser_1.parseLog.debug('encountered non-if token for supposed if-then structure');
         return undefined;
     }
-    else if (tokens[1].name !== "(" /* RawRType.ParenLeft */) {
+    else if (tokens[1].name !== type_1.RawRType.ParenLeft) {
         throw new input_format_1.XmlParseError(`expected left-parenthesis for if but found ${JSON.stringify(tokens[1])}`);
     }
-    else if (tokens[3].name !== ")" /* RawRType.ParenRight */) {
+    else if (tokens[3].name !== type_1.RawRType.ParenRight) {
         throw new input_format_1.XmlParseError(`expected right-parenthesis for if but found ${JSON.stringify(tokens[3])}`);
     }
     const parsedCondition = (0, normalize_single_node_1.normalizeSingleNode)(data, tokens[2]);
     const parsedThen = (0, normalize_single_node_1.normalizeSingleNode)(data, tokens[4]);
-    if (parsedCondition.type === "RDelimiter" /* RType.Delimiter */ || parsedThen.type === "RDelimiter" /* RType.Delimiter */) {
+    if (parsedCondition.type === type_1.RType.Delimiter || parsedThen.type === type_1.RType.Delimiter) {
         throw new input_format_1.XmlParseError(`unexpected missing parts of if, received ${JSON.stringify([parsedCondition, parsedThen])} for ${JSON.stringify(tokens)}`);
     }
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(tokens[0].content);
     return {
-        type: "RIfThenElse" /* RType.IfThenElse */,
+        type: type_1.RType.IfThenElse,
         condition: parsedCondition,
         then: (0, normalize_meta_1.ensureExpressionList)(parsedThen),
         location,
@@ -39,5 +40,4 @@ function tryNormalizeIfThen(data, tokens) {
         }
     };
 }
-exports.tryNormalizeIfThen = tryNormalizeIfThen;
 //# sourceMappingURL=normalize-if-then.js.map

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeExpression = void 0;
+exports.normalizeExpression = normalizeExpression;
 const input_format_1 = require("../../input-format");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
@@ -9,6 +9,7 @@ const arrays_1 = require("../../../../../../../util/arrays");
 const normalize_expressions_1 = require("../structure/normalize-expressions");
 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");
 /**
  * Returns an expression list if there are multiple children, otherwise returns the single child directly with no expr wrapper
@@ -39,7 +40,7 @@ function normalizeExpression(data, obj) {
         return maybeFunctionDefinition;
     }
     const children = (0, normalize_expressions_1.normalizeExpressions)(childData, childrenSource);
-    const [delimiters, nodes] = (0, arrays_1.partition)(children, x => x.type === "RDelimiter" /* RType.Delimiter */ || x.type === "RComment" /* RType.Comment */);
+    const [delimiters, nodes] = (0, arrays_1.partition)(children, x => x.type === type_1.RType.Delimiter || x.type === type_1.RType.Comment);
     if (nodes.length === 1) {
         const result = nodes[0];
         result.info.additionalTokens = [...result.info.additionalTokens ?? [], ...delimiters];
@@ -47,7 +48,7 @@ function normalizeExpression(data, obj) {
     }
     else {
         return {
-            type: "RExpressionList" /* RType.ExpressionList */,
+            type: type_1.RType.ExpressionList,
             grouping: undefined,
             location,
             children: nodes,
@@ -60,5 +61,4 @@ function normalizeExpression(data, obj) {
         };
     }
 }
-exports.normalizeExpression = normalizeExpression;
 //# sourceMappingURL=normalize-expression.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/normalize-argument.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryToNormalizeArgument = void 0;
+exports.tryToNormalizeArgument = tryToNormalizeArgument;
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const assert_1 = require("../../../../../../../util/assert");
+const type_1 = require("../../../../model/type");
 const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
  * Either parses `[expr]` or `[SYMBOL_SUB, EQ_SUB, expr]` as an argument of a function call in R.
@@ -24,15 +25,15 @@ function tryToNormalizeArgument(data, objs) {
     const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(symbolOrExpr.content);
     let parsedValue;
     let name;
-    if (symbolOrExpr.name === "expr" /* RawRType.Expression */) {
+    if (symbolOrExpr.name === type_1.RawRType.Expression) {
         name = undefined;
         parsedValue = (0, normalize_single_node_1.normalizeSingleNode)(data, symbolOrExpr);
     }
-    else if (symbolOrExpr.name === "SYMBOL_SUB" /* RawRType.SymbolSub */ || symbolOrExpr.name === "STR_CONST" /* RawRType.StringConst */) {
+    else if (symbolOrExpr.name === type_1.RawRType.SymbolSub || symbolOrExpr.name === type_1.RawRType.StringConst) {
         name = {
-            type: "RSymbol" /* RType.Symbol */,
+            type: type_1.RType.Symbol,
             location,
-            content: symbolOrExpr.name === "STR_CONST" /* RawRType.StringConst */ ? content.slice(1, -1) : content,
+            content: symbolOrExpr.name === type_1.RawRType.StringConst ? content.slice(1, -1) : content,
             namespace: undefined,
             lexeme: content,
             info: {
@@ -47,9 +48,9 @@ function tryToNormalizeArgument(data, objs) {
         parser_1.parseLog.warn(`expected symbol or expr for argument, yet received ${objs.map(o => o.name).join(',')}`);
         return undefined;
     }
-    (0, assert_1.guard)(parsedValue !== undefined && parsedValue?.type !== "RDelimiter" /* RType.Delimiter */, () => `[argument] parsed value must not be undefined, yet: ${JSON.stringify(objs)}`);
+    (0, assert_1.guard)(parsedValue !== undefined && parsedValue?.type !== type_1.RType.Delimiter, () => `[argument] parsed value must not be undefined, yet: ${JSON.stringify(objs)}`);
     return {
-        type: "RArgument" /* RType.Argument */,
+        type: type_1.RType.Argument,
         location,
         lexeme: content,
         name,
@@ -61,10 +62,9 @@ function tryToNormalizeArgument(data, objs) {
         }
     };
 }
-exports.tryToNormalizeArgument = tryToNormalizeArgument;
 function parseWithValue(data, objs) {
-    (0, assert_1.guard)(objs[1].name === "EQ_SUB" /* RawRType.EqualSub */, () => `[arg-default] second element of parameter must be ${"EQ_FORMALS" /* RawRType.EqualFormals */}, but: ${JSON.stringify(objs)}`);
-    (0, assert_1.guard)(objs.length === 2 || objs[2].name === "expr" /* RawRType.Expression */, () => `[arg-default] third element of parameter must be an Expression or undefined (for 'x=') but: ${JSON.stringify(objs)}`);
+    (0, assert_1.guard)(objs[1].name === type_1.RawRType.EqualSub, () => `[arg-default] second element of parameter must be ${type_1.RawRType.EqualFormals}, but: ${JSON.stringify(objs)}`);
+    (0, assert_1.guard)(objs.length === 2 || objs[2].name === type_1.RawRType.Expression, () => `[arg-default] third element of parameter must be an Expression or undefined (for 'x=') but: ${JSON.stringify(objs)}`);
     return objs[2] ? (0, normalize_single_node_1.normalizeSingleNode)(data, objs[2]) : null;
 }
 //# sourceMappingURL=normalize-argument.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/normalize-call.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryNormalizeFunctionCall = void 0;
+exports.tryNormalizeFunctionCall = tryNormalizeFunctionCall;
 const input_format_1 = require("../../input-format");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
@@ -8,6 +8,7 @@ const arrays_1 = require("../../../../../../../util/arrays");
 const assert_1 = require("../../../../../../../util/assert");
 const normalize_argument_1 = require("./normalize-argument");
 const r_function_call_1 = require("../../../../model/nodes/r-function-call");
+const type_1 = require("../../../../model/type");
 const normalize_expression_1 = require("../expression/normalize-expression");
 const normalize_string_1 = require("../values/normalize-string");
 const normalize_symbol_1 = require("../values/normalize-symbol");
@@ -22,11 +23,11 @@ const normalize_symbol_1 = require("../values/normalize-symbol");
  */
 function tryNormalizeFunctionCall(data, mappedWithName) {
     const fnBase = mappedWithName[0];
-    if (fnBase.name !== "expr" /* RawRType.Expression */ && fnBase.name !== "expr_or_assign_or_help" /* RawRType.ExprOfAssignOrHelp */ && fnBase.name !== "equal_assign" /* RawRType.LegacyEqualAssign */) {
+    if (fnBase.name !== type_1.RawRType.Expression && fnBase.name !== type_1.RawRType.ExprOfAssignOrHelp && fnBase.name !== type_1.RawRType.LegacyEqualAssign) {
         parser_1.parseLog.trace(`expected function call name to be wrapped an expression, yet received ${fnBase.name}`);
         return undefined;
     }
-    if (mappedWithName.length < 3 || mappedWithName[1].name !== "(" /* RawRType.ParenLeft */ || mappedWithName[mappedWithName.length - 1].name !== ")" /* RawRType.ParenRight */) {
+    if (mappedWithName.length < 3 || mappedWithName[1].name !== type_1.RawRType.ParenLeft || mappedWithName[mappedWithName.length - 1].name !== type_1.RawRType.ParenRight) {
         parser_1.parseLog.trace('expected function call to have parenthesis for a call, but was not');
         return undefined;
     }
@@ -34,12 +35,12 @@ function tryNormalizeFunctionCall(data, mappedWithName) {
     const { unwrappedObj, content, location } = (0, normalize_meta_1.retrieveMetaStructure)(fnBase.content);
     const symbolContent = (0, input_format_1.getKeyGuarded)(unwrappedObj, input_format_1.childrenKey);
     const namedSymbolContent = (0, normalize_meta_1.getWithTokenType)(symbolContent);
-    if (namedSymbolContent.length === 1 && namedSymbolContent[0].name === "STR_CONST" /* RawRType.StringConst */) {
+    if (namedSymbolContent.length === 1 && namedSymbolContent[0].name === type_1.RawRType.StringConst) {
         // special handling when someone calls a function by string
         return parseNamedFunctionCall(data, namedSymbolContent, mappedWithName, location, content);
     }
-    else if (namedSymbolContent.findIndex(x => x.name === "SYMBOL_FUNCTION_CALL" /* RawRType.SymbolFunctionCall */) < 0) {
-        parser_1.parseLog.trace(`is not named function call, as the name is not of type ${"RFunctionCall" /* RType.FunctionCall */}, but: ${namedSymbolContent.map(n => n.name).join(',')}`);
+    else if (namedSymbolContent.findIndex(x => x.name === type_1.RawRType.SymbolFunctionCall) < 0) {
+        parser_1.parseLog.trace(`is not named function call, as the name is not of type ${type_1.RType.FunctionCall}, but: ${namedSymbolContent.map(n => n.name).join(',')}`);
         const mayResult = tryParseUnnamedFunctionCall(data, mappedWithName, location, content);
         return mayResult;
     }
@@ -47,11 +48,10 @@ function tryNormalizeFunctionCall(data, mappedWithName) {
         return parseNamedFunctionCall(data, namedSymbolContent, mappedWithName, location, content);
     }
 }
-exports.tryNormalizeFunctionCall = tryNormalizeFunctionCall;
 function parseArguments(mappedWithName, data) {
     const argContainer = mappedWithName.slice(1);
-    (0, assert_1.guard)(argContainer.length > 1 && argContainer[0].name === "(" /* RawRType.ParenLeft */ && argContainer[argContainer.length - 1].name === ")" /* RawRType.ParenRight */, 'expected args in parenthesis');
-    const splitArgumentsOnComma = (0, arrays_1.splitArrayOn)(argContainer.slice(1, argContainer.length - 1), x => x.name === "," /* RawRType.Comma */);
+    (0, assert_1.guard)(argContainer.length > 1 && argContainer[0].name === type_1.RawRType.ParenLeft && argContainer[argContainer.length - 1].name === type_1.RawRType.ParenRight, 'expected args in parenthesis');
+    const splitArgumentsOnComma = (0, arrays_1.splitArrayOn)(argContainer.slice(1, argContainer.length - 1), x => x.name === type_1.RawRType.Comma);
     return splitArgumentsOnComma.map(x => {
         parser_1.parseLog.trace('trying to parse argument');
         return (0, normalize_argument_1.tryToNormalizeArgument)(data, x);
@@ -69,9 +69,9 @@ function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
     const parsedArguments = parseArguments(mappedWithName, data);
     if (parsedArguments.length === 0) {
         // sadly, next() and break() work
-        if (calledFunction.type === "RNext" /* RType.Next */) {
+        if (calledFunction.type === type_1.RType.Next) {
             return {
-                type: "RNext" /* RType.Next */,
+                type: type_1.RType.Next,
                 lexeme: content,
                 location,
                 info: {
@@ -81,9 +81,9 @@ function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
                 }
             };
         }
-        else if (calledFunction.type === "RBreak" /* RType.Break */) {
+        else if (calledFunction.type === type_1.RType.Break) {
             return {
-                type: "RBreak" /* RType.Break */,
+                type: type_1.RType.Break,
                 lexeme: content,
                 location,
                 info: {
@@ -95,7 +95,7 @@ function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
         }
     }
     return {
-        type: "RFunctionCall" /* RType.FunctionCall */,
+        type: type_1.RType.FunctionCall,
         named: undefined,
         location,
         lexeme: content,
@@ -110,10 +110,10 @@ function tryParseUnnamedFunctionCall(data, mappedWithName, location, content) {
 }
 function parseNamedFunctionCall(data, symbolContent, mappedWithName, location, content) {
     let functionName;
-    if (symbolContent.length === 1 && symbolContent[0].name === "STR_CONST" /* RawRType.StringConst */) {
+    if (symbolContent.length === 1 && symbolContent[0].name === type_1.RawRType.StringConst) {
         const stringBase = (0, normalize_string_1.normalizeString)(data, symbolContent[0].content);
         functionName = {
-            type: "RSymbol" /* RType.Symbol */,
+            type: type_1.RType.Symbol,
             namespace: undefined,
             lexeme: stringBase.lexeme,
             info: stringBase.info,
@@ -125,10 +125,10 @@ function parseNamedFunctionCall(data, symbolContent, mappedWithName, location, c
         functionName = (0, normalize_symbol_1.tryNormalizeSymbol)(data, symbolContent);
     }
     (0, assert_1.guard)(functionName !== undefined, 'expected function name to be a symbol, yet received none');
-    (0, assert_1.guard)((functionName).type === "RSymbol" /* RType.Symbol */, () => `expected function name to be a symbol, yet received ${JSON.stringify(functionName)}`);
+    (0, assert_1.guard)((functionName).type === type_1.RType.Symbol, () => `expected function name to be a symbol, yet received ${JSON.stringify(functionName)}`);
     const parsedArguments = parseArguments(mappedWithName, data);
     return {
-        type: "RFunctionCall" /* RType.FunctionCall */,
+        type: type_1.RType.FunctionCall,
         named: true,
         location,
         lexeme: content,