@eagleoutice/flowr 1.5.2 → 2.0.1

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.foldAstStateful = void 0;
 const assert_1 = require("../../../../../util/assert");
+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.
  */
@@ -22,13 +23,13 @@ function foldAstStateful(ast, down, folds) {
         case "RLineDirective" /* RType.LineDirective */:
             return folds.other.foldLineDirective(ast, down);
         case "RPipe" /* RType.Pipe */:
-            return folds.binaryOp.foldPipe(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
+            return folds.foldPipe(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
         case "RBinaryOp" /* RType.BinaryOp */:
-            return foldBinaryOp(ast, down, folds);
+            return folds.foldBinaryOp(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
         case "RUnaryOp" /* RType.UnaryOp */:
-            return foldUnaryOp(ast, down, folds);
+            return folds.foldUnaryOp(ast, foldAstStateful(ast.operand, down, folds), down);
         case "RAccess" /* RType.Access */:
-            return folds.foldAccess(ast, foldAstStateful(ast.accessed, down, folds), ast.operator === '[' || ast.operator === '[[' ? ast.access.map(access => access === null ? null : foldAstStateful(access, down, folds)) : ast.access, down);
+            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 */:
             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 */:
@@ -36,7 +37,7 @@ function foldAstStateful(ast, down, folds) {
         case "RRepeatLoop" /* RType.RepeatLoop */:
             return folds.loop.foldRepeat(ast, foldAstStateful(ast.body, down, folds), down);
         case "RFunctionCall" /* RType.FunctionCall */:
-            return folds.functions.foldFunctionCall(ast, foldAstStateful(ast.flavor === 'named' ? ast.functionName : ast.calledFunction, down, folds), ast.arguments.map(param => param === undefined ? param : foldAstStateful(param, down, folds)), down);
+            return folds.functions.foldFunctionCall(ast, foldAstStateful(ast.flavor === '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 */:
             return folds.functions.foldFunctionDefinition(ast, ast.parameters.map(param => foldAstStateful(param, down, folds)), foldAstStateful(ast.body, down, folds), down);
         case "RParameter" /* RType.Parameter */:
@@ -50,38 +51,10 @@ function foldAstStateful(ast, down, folds) {
         case "RIfThenElse" /* 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 */:
-            return folds.foldExprList(ast, ast.children.map(expr => foldAstStateful(expr, down, folds)), down);
+            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;
-function foldBinaryOp(ast, down, folds) {
-    switch (ast.flavor) {
-        case 'logical':
-            return folds.binaryOp.foldLogicalOp(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
-        case 'arithmetic':
-            return folds.binaryOp.foldArithmeticOp(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
-        case 'comparison':
-            return folds.binaryOp.foldComparisonOp(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
-        case 'assignment':
-            return folds.binaryOp.foldAssignment(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
-        case 'model formula':
-            return folds.binaryOp.foldModelFormula(ast, foldAstStateful(ast.lhs, down, folds), foldAstStateful(ast.rhs, down, folds), down);
-        default:
-            (0, assert_1.assertUnreachable)(ast.flavor);
-    }
-}
-function foldUnaryOp(ast, down, folds) {
-    switch (ast.flavor) {
-        case 'logical':
-            return folds.unaryOp.foldLogicalOp(ast, foldAstStateful(ast.operand, down, folds), down);
-        case 'arithmetic':
-            return folds.unaryOp.foldArithmeticOp(ast, foldAstStateful(ast.operand, down, folds), down);
-        case 'model formula':
-            return folds.unaryOp.foldModelFormula(ast, foldAstStateful(ast.operand, down, folds), down);
-        default:
-            (0, assert_1.assertUnreachable)(ast.flavor);
-    }
-}
 //# sourceMappingURL=stateful-fold.js.map

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.visitAst = void 0;
 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
 class NodeVisitor {
     onEnter;
@@ -26,6 +27,7 @@ class NodeVisitor {
                 this.visitSingle(node.body);
                 break;
             case "RExpressionList" /* RType.ExpressionList */:
+                this.visit(node.grouping);
                 this.visit(node.children);
                 break;
             case "RForLoop" /* RType.ForLoop */:
@@ -84,8 +86,9 @@ class NodeVisitor {
     }
     visit(nodes) {
         if (Array.isArray(nodes)) {
-            for (const node of nodes) {
-                if (node) {
+            const n = nodes;
+            for (const node of n) {
+                if (node && node !== r_function_call_1.EmptyArgument) {
                     this.visitSingle(node);
                 }
             }

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

@@ -1,18 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSymbol = void 0;
+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 */,
+]);
 /**
  * Validates, whether the given type can be used as a symbol in R
  *
  * @see RawRType
  */
 function isSymbol(type) {
-    return (type === "SYMBOL" /* RawRType.Symbol */ ||
-        type === "SYMBOL_PACKAGE" /* RawRType.SymbolPackage */ ||
-        type === "SYMBOL_FUNCTION_CALL" /* RawRType.SymbolFunctionCall */ ||
-        type === "NULL_CONST" /* RawRType.NullConst */ ||
-        type === "STR_CONST" /* RawRType.StringConst */ ||
-        type === "SLOT" /* RawRType.Slot */);
+    return validSymbolTypes.has(type);
 }
 exports.isSymbol = isSymbol;
 //# sourceMappingURL=type.js.map

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

@@ -11,4 +11,7 @@ export interface Entry extends Record<string, unknown> {
     text: string;
     children?: Entry[];
 }
-export declare function prepareParsedData(data: string): Map<number, Entry>;
+/**
+ * Parses the given data and sets child relationship, return the list of root entries (with a parent of {@link RootId}).
+ */
+export declare function prepareParsedData(data: string): Entry[];

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

@@ -4,12 +4,16 @@ exports.prepareParsedData = exports.RootId = void 0;
 const retriever_1 = require("../../../../retriever");
 const assert_1 = require("../../../../../util/assert");
 exports.RootId = 0;
+/**
+ * Parses the given data and sets child relationship, return the list of root entries (with a parent of {@link RootId}).
+ */
 function prepareParsedData(data) {
-    const json = JSON.parse(data);
+    const json = JSON.parse(`[${data}]`);
     (0, assert_1.guard)(Array.isArray(json), () => `Expected ${data} to be an array but was not`);
     const ret = new Map(json.map(([line1, col1, line2, col2, id, parent, token, terminal, text]) => {
         return [id, { line1, col1, line2, col2, id, parent, token: (0, retriever_1.removeRQuotes)(token), terminal, text }];
     }));
+    const roots = [];
     // iterate a second time to set parent-child relations (since they may be out of order in the csv)
     for (const entry of ret.values()) {
         if (entry.parent != exports.RootId) {
@@ -19,8 +23,11 @@ function prepareParsedData(data) {
                 parent.children.push(entry);
             }
         }
+        else {
+            roots.push(entry);
+        }
     }
-    return ret;
+    return roots;
 }
 exports.prepareParsedData = prepareParsedData;
 //# sourceMappingURL=format.js.map

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

@@ -1,7 +1,7 @@
-import type { DeepPartial } from 'ts-essentials';
-import type { XmlBasedJson, XmlParserHooks } from '../xml';
-import type { IdGenerator, NoInfo, NormalizedAst } from '../../model';
 import type { Entry } from './format';
+import type { IdGenerator, NormalizedAst } from '../../model/processing/decorate';
+import type { NoInfo } from '../../model/model';
+import type { XmlBasedJson } from '../xml/input-format';
 export declare const parseLog: import("tslog").Logger<import("tslog").ILogObj>;
-export declare function normalize(jsonString: string, hooks?: DeepPartial<XmlParserHooks>, getId?: IdGenerator<NoInfo>): NormalizedAst;
-export declare function convertPreparedParsedData(valueMapping: Map<number, Entry>): XmlBasedJson;
+export declare function normalize(jsonString: string, getId?: IdGenerator<NoInfo>): NormalizedAst;
+export declare function convertPreparedParsedData(rootEntries: Entry[]): XmlBasedJson;

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

@@ -1,48 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertPreparedParsedData = exports.normalize = exports.parseLog = void 0;
-const xml_1 = require("../xml");
-const model_1 = require("../../model");
-const objects_1 = require("../../../../../util/objects");
 const format_1 = require("./format");
-const internal_1 = require("../xml/internal");
 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");
 exports.parseLog = log_1.log.getSubLogger({ name: 'ast-parser' });
-function normalize(jsonString, hooks, getId = (0, model_1.deterministicCountingIdGenerator)(0)) {
-    const hooksWithDefaults = (0, objects_1.deepMergeObject)(xml_1.DEFAULT_PARSER_HOOKS, hooks);
-    const data = { hooks: hooksWithDefaults, currentRange: undefined, currentLexeme: undefined };
+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, model_1.decorateAst)((0, internal_1.parseRootObjToAst)(data, object), getId);
+    return (0, decorate_1.decorateAst)((0, normalize_root_1.normalizeRootObjToAst)(data, object), getId);
 }
 exports.normalize = normalize;
-function convertPreparedParsedData(valueMapping) {
-    const exprlist = {};
-    exprlist[xml_1.nameKey] = 'exprlist';
-    const children = [];
-    for (const entry of valueMapping.values()) {
-        if (entry.parent == format_1.RootId) {
-            children.push(convertEntry(entry));
+function convertPreparedParsedData(rootEntries) {
+    return {
+        ["exprlist" /* RawRType.ExpressionList */]: {
+            [input_format_1.nameKey]: "exprlist" /* RawRType.ExpressionList */,
+            [input_format_1.childrenKey]: rootEntries.map(convertEntry)
         }
-    }
-    exprlist[xml_1.childrenKey] = children;
-    return { 'exprlist': exprlist };
+    };
 }
 exports.convertPreparedParsedData = convertPreparedParsedData;
 function convertEntry(csvEntry) {
-    const xmlEntry = {};
-    xmlEntry[xml_1.attributesKey] = {
-        'line1': csvEntry.line1,
-        'col1': csvEntry.col1,
-        'line2': csvEntry.line2,
-        'col2': csvEntry.col2
+    const xmlEntry = {
+        [input_format_1.nameKey]: csvEntry.token,
+        [input_format_1.attributesKey]: {
+            'line1': csvEntry.line1,
+            'col1': csvEntry.col1,
+            'line2': csvEntry.line2,
+            'col2': csvEntry.col2
+        }
     };
-    xmlEntry[xml_1.nameKey] = csvEntry.token;
     if (csvEntry.text) {
-        xmlEntry[xml_1.contentKey] = csvEntry.text;
+        xmlEntry[input_format_1.contentKey] = csvEntry.text;
     }
     // check and recursively iterate children
     if (csvEntry.children && csvEntry.children.length > 0) {
-        xmlEntry[xml_1.childrenKey] = csvEntry.children
+        xmlEntry[input_format_1.childrenKey] = csvEntry.children
             // we sort children the same way xmlparsedata does (by line, by column, by inverse end line, by inverse end column, by terminal state, by combined "start" tiebreaker value)
             // (https://github.com/r-lib/xmlparsedata/blob/main/R/package.R#L153C72-L153C78)
             .sort((c1, c2) => c1.line1 - c2.line1 || c1.col1 - c2.col1 || c2.line2 - c1.line2 || c2.col2 - c1.col2 || Number(c1.terminal) - Number(c2.terminal) || sortTiebreak(c1) - sortTiebreak(c2))

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

@@ -1,4 +1,4 @@
-import type { RawRType } from '../../model';
+import type { RawRType } from '../../model/type';
 export declare const attributesKey = "a";
 export declare const childrenKey = "c";
 export declare const contentKey = "@";
@@ -16,21 +16,24 @@ export type XmlBasedJson = Record<string, XmlBasedJsonValue>;
 /**
  * A xml element in the json can either link to a string or another xml element
  */
-export type XmlBasedJsonValue = string | Record<string, unknown> | XmlBasedJson[];
+export type XmlBasedJsonValue = string | Record<string, unknown> | readonly XmlBasedJson[];
 /**
  * We expect all xml elements to have a name attached which represents their R token type.
  */
 export interface NamedXmlBasedJson {
     /** corresponds to the R token type */
-    name: RawRType;
+    readonly name: RawRType;
     /** remaining content (e.g., children, ...) */
-    content: XmlBasedJson;
+    readonly content: XmlBasedJson;
 }
 /**
- * Retrieves the given key(s) from the converted xml.
+ * Single-key variant of {@link getKeysGuarded}. Will throw an {@link XmlParseError} if the key is not present.
+ */
+export declare function getKeyGuarded<T extends XmlBasedJsonValue>(obj: XmlBasedJson, key: string): T;
+/**
+ * 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
  *
  * @typeParam T - the type of the values to retrieve. Note, that this type is not checked at runtime.
  */
-export declare function getKeysGuarded<T extends XmlBasedJsonValue>(obj: XmlBasedJson, key: string): T;
-export declare function getKeysGuarded<T extends XmlBasedJsonValue>(obj: XmlBasedJson, ...key: readonly string[]): Record<string, T>;
+export declare function getKeysGuarded<T extends XmlBasedJsonValue>(obj: XmlBasedJson, ...keys: readonly string[]): Record<string, T>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getKeysGuarded = exports.XmlParseError = exports.nameKey = exports.contentKey = exports.childrenKey = exports.attributesKey = void 0;
+exports.getKeysGuarded = exports.getKeyGuarded = exports.XmlParseError = exports.nameKey = exports.contentKey = exports.childrenKey = exports.attributesKey = void 0;
 exports.attributesKey = 'a';
 exports.childrenKey = 'c';
 exports.contentKey = '@';
@@ -15,16 +15,24 @@ class XmlParseError extends Error {
     }
 }
 exports.XmlParseError = XmlParseError;
-function getKeysGuarded(obj, ...key) {
-    if (key.length === 1) {
-        return obj[key[0]];
-    }
-    else {
-        return key.reduce((acc, key) => {
-            acc[key] = obj[key];
-            return acc;
-        }, {});
-    }
+function error(key, obj) {
+    throw new XmlParseError(`expected obj to have key ${key}, yet received ${JSON.stringify(obj)}`);
+}
+/**
+ * Single-key variant of {@link getKeysGuarded}. Will throw an {@link XmlParseError} if the key is not present.
+ */
+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
+ *
+ * @typeParam T - the type of the values to retrieve. Note, that this type is not checked at runtime.
+ */
+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/{if-then-else.d.ts → normalize-if-then-else.d.ts}

@@ -1,10 +1,10 @@
+import type { NormalizerData } from '../../normalizer-data';
 import type { NamedXmlBasedJson } from '../../input-format';
-import type { ParserData } from '../../data';
-import type { RIfThenElse } from '../../../../model';
+import type { RIfThenElse } from '../../../../model/nodes/r-if-then-else';
 /**
  * Try to parse the construct as a {@link RIfThenElse}.
  */
-export declare function tryNormalizeIfThenElse(data: ParserData, tokens: [
+export declare function tryNormalizeIfThenElse(data: NormalizerData, tokens: [
     ifToken: NamedXmlBasedJson,
     leftParen: NamedXmlBasedJson,
     condition: NamedXmlBasedJson,

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

@@ -1,32 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeIfThenElse = void 0;
-const structure_1 = require("../structure");
-const if_then_1 = require("./if-then");
-const assert_1 = require("../../../../../../../util/assert");
-const hooks_1 = require("../../hooks");
-const meta_1 = require("../meta");
 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");
 /**
  * Try to parse the construct as a {@link RIfThenElse}.
  */
 function tryNormalizeIfThenElse(data, tokens) {
     // we start by parsing a regular if-then structure
     parser_1.parseLog.trace('trying to parse if-then-else structure');
-    tokens = (0, hooks_1.executeHook)(data.hooks.control.onIfThenElse.before, data, tokens);
-    const parsedIfThen = (0, if_then_1.tryNormalizeIfThen)(data, [tokens[0], tokens[1], tokens[2], tokens[3], tokens[4]]);
+    const parsedIfThen = (0, normalize_if_then_1.tryNormalizeIfThen)(data, [tokens[0], tokens[1], tokens[2], tokens[3], tokens[4]]);
     if (parsedIfThen === undefined) {
-        return (0, hooks_1.executeUnknownHook)(data.hooks.control.onIfThenElse.unknown, 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])}`);
-    const parsedElse = (0, structure_1.tryNormalizeSingleNode)(data, tokens[6]);
+    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)}`);
-    const result = {
+    return {
         ...parsedIfThen,
-        otherwise: (0, meta_1.ensureExpressionList)(parsedElse)
+        otherwise: (0, normalize_meta_1.ensureExpressionList)(parsedElse)
     };
-    return (0, hooks_1.executeHook)(data.hooks.control.onIfThenElse.after, data, result);
 }
 exports.tryNormalizeIfThenElse = tryNormalizeIfThenElse;
-//# sourceMappingURL=if-then-else.js.map
+//# sourceMappingURL=normalize-if-then-else.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/control/{if-then.d.ts → normalize-if-then.d.ts}

@@ -1,10 +1,10 @@
+import type { NormalizerData } from '../../normalizer-data';
 import type { NamedXmlBasedJson } from '../../input-format';
-import type { ParserData } from '../../data';
-import type { RIfThenElse } from '../../../../model';
+import type { RIfThenElse } from '../../../../model/nodes/r-if-then-else';
 /**
  * Try to parse the construct as a {@link RIfThenElse}.
  */
-export declare function tryNormalizeIfThen(data: ParserData, tokens: [
+export declare function tryNormalizeIfThen(data: NormalizerData, tokens: [
     ifToken: NamedXmlBasedJson,
     leftParen: NamedXmlBasedJson,
     condition: NamedXmlBasedJson,

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

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeIfThen = void 0;
 const input_format_1 = require("../../input-format");
-const structure_1 = require("../structure");
-const meta_1 = require("../meta");
-const hooks_1 = require("../../hooks");
 const parser_1 = require("../../../json/parser");
+const normalize_meta_1 = require("../../normalize-meta");
+const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
  * Try to parse the construct as a {@link RIfThenElse}.
  */
@@ -13,7 +12,7 @@ function tryNormalizeIfThen(data, tokens) {
     parser_1.parseLog.trace('trying to parse if-then structure');
     if (tokens[0].name !== "IF" /* RawRType.If */) {
         parser_1.parseLog.debug('encountered non-if token for supposed if-then structure');
-        return (0, hooks_1.executeUnknownHook)(data.hooks.control.onIfThen.unknown, data, tokens);
+        return undefined;
     }
     else if (tokens[1].name !== "(" /* RawRType.ParenLeft */) {
         throw new input_format_1.XmlParseError(`expected left-parenthesis for if but found ${JSON.stringify(tokens[1])}`);
@@ -21,17 +20,16 @@ function tryNormalizeIfThen(data, tokens) {
     else if (tokens[3].name !== ")" /* RawRType.ParenRight */) {
         throw new input_format_1.XmlParseError(`expected right-parenthesis for if but found ${JSON.stringify(tokens[3])}`);
     }
-    tokens = (0, hooks_1.executeHook)(data.hooks.control.onIfThen.before, data, tokens);
-    const parsedCondition = (0, structure_1.tryNormalizeSingleNode)(data, tokens[2]);
-    const parsedThen = (0, structure_1.tryNormalizeSingleNode)(data, tokens[4]);
+    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 */) {
         throw new input_format_1.XmlParseError(`unexpected missing parts of if, received ${JSON.stringify([parsedCondition, parsedThen])} for ${JSON.stringify(tokens)}`);
     }
-    const { location, content } = (0, meta_1.retrieveMetaStructure)(tokens[0].content);
-    const result = {
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(tokens[0].content);
+    return {
         type: "RIfThenElse" /* RType.IfThenElse */,
         condition: parsedCondition,
-        then: (0, meta_1.ensureExpressionList)(parsedThen),
+        then: (0, normalize_meta_1.ensureExpressionList)(parsedThen),
         location,
         lexeme: content,
         info: {
@@ -40,7 +38,6 @@ function tryNormalizeIfThen(data, tokens) {
             fullLexeme: data.currentLexeme
         }
     };
-    return (0, hooks_1.executeHook)(data.hooks.control.onIfThen.after, data, result);
 }
 exports.tryNormalizeIfThen = tryNormalizeIfThen;
-//# sourceMappingURL=if-then.js.map
+//# sourceMappingURL=normalize-if-then.js.map

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

@@ -0,0 +1,10 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { XmlBasedJson } from '../../input-format';
+import type { RNode } from '../../../../model/model';
+/**
+ * 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})
+ * @param obj  - The json object to extract the meta-information from
+ */
+export declare function normalizeExpression(data: NormalizerData, obj: XmlBasedJson): RNode;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExpression = void 0;
+const input_format_1 = require("../../input-format");
+const parser_1 = require("../../../json/parser");
+const normalize_meta_1 = require("../../normalize-meta");
+const normalize_access_1 = require("../normalize-access");
+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 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
+ *
+ * @param data - The data used by the parser (see {@link NormalizerData})
+ * @param obj  - The json object to extract the meta-information from
+ */
+function normalizeExpression(data, obj) {
+    parser_1.parseLog.debug('[expr]');
+    const { unwrappedObj, content, location } = (0, normalize_meta_1.retrieveMetaStructure)(obj);
+    const childrenSource = (0, input_format_1.getKeyGuarded)(unwrappedObj, input_format_1.childrenKey);
+    const typed = (0, normalize_meta_1.getWithTokenType)(childrenSource);
+    const { others, comments } = (0, normalize_expressions_1.splitComments)(typed);
+    const childData = { ...data, currentRange: location, currentLexeme: content };
+    const maybeFunctionCall = (0, normalize_call_1.tryNormalizeFunctionCall)(childData, others);
+    if (maybeFunctionCall !== undefined) {
+        maybeFunctionCall.info.additionalTokens = [...maybeFunctionCall.info.additionalTokens ?? [], ...comments.map(x => (0, normalize_comment_1.normalizeComment)(data, x.content))];
+        return maybeFunctionCall;
+    }
+    const maybeAccess = (0, normalize_access_1.tryNormalizeAccess)(childData, others);
+    if (maybeAccess !== undefined) {
+        maybeAccess.info.additionalTokens = [...maybeAccess.info.additionalTokens ?? [], ...comments.map(x => (0, normalize_comment_1.normalizeComment)(data, x.content))];
+        return maybeAccess;
+    }
+    const maybeFunctionDefinition = (0, normalize_definition_1.tryNormalizeFunctionDefinition)(childData, others);
+    if (maybeFunctionDefinition !== undefined) {
+        maybeFunctionDefinition.info.additionalTokens = [...maybeFunctionDefinition.info.additionalTokens ?? [], ...comments.map(x => (0, normalize_comment_1.normalizeComment)(data, x.content))];
+        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 */);
+    if (nodes.length === 1) {
+        const result = nodes[0];
+        result.info.additionalTokens = [...result.info.additionalTokens ?? [], ...delimiters];
+        return result;
+    }
+    else {
+        return {
+            type: "RExpressionList" /* RType.ExpressionList */,
+            grouping: undefined,
+            location,
+            children: nodes,
+            lexeme: content,
+            info: {
+                fullRange: childData.currentRange,
+                additionalTokens: delimiters,
+                fullLexeme: childData.currentLexeme
+            }
+        };
+    }
+}
+exports.normalizeExpression = normalizeExpression;
+//# sourceMappingURL=normalize-expression.js.map

package/r-bridge/lang-4.x/ast/parser/xml/internal/functions/{argument.d.ts → normalize-argument.d.ts}

@@ -1,13 +1,13 @@
+import type { NormalizerData } from '../../normalizer-data';
 import type { NamedXmlBasedJson } from '../../input-format';
-import type { RArgument } from '../../../../model';
-import type { ParserData } from '../../data';
+import type { RArgument } from '../../../../model/nodes/r-argument';
 /**
  * Either parses `[expr]` or `[SYMBOL_SUB, EQ_SUB, expr]` as an argument of a function call in R.
  * Probably directly called by the function call parser as otherwise, we do not expect to find arguments.
  *
- * @param data - The data used by the parser (see {@link ParserData})
+ * @param data - The data used by the parser (see {@link NormalizerData})
  * @param objs - Either `[expr]` or `[SYMBOL_FORMALS, EQ_FORMALS, expr]`
  *
  * @returns The parsed argument or `undefined` if the given object is not an argument.
  */
-export declare function tryToNormalizeArgument(data: ParserData, objs: NamedXmlBasedJson[]): RArgument | undefined;
+export declare function tryToNormalizeArgument(data: NormalizerData, objs: readonly NamedXmlBasedJson[]): RArgument | undefined;