WIP: Work a bit on the expression parsing

src/Lib/Script/Ast/Parser/IrExpression.hh

@@ -5,41 +5,53 @@ auto throwUnexpectedToken = [](const Token &tok) {
                              tok.toString());
 };
 
+auto createOpElement = []<typename IrT>(IrExpression *&current, Token tok) -> IrT* {
+    return dynamic_cast<IrExpression *>(IrElement::create<IrT>(
+        nullptr,                    /* The parent, will be set later    */
+        IrT::getOpFromToken(tok),   /* The type of operation (+,-,...)  */
+        std::move(nullptr),         /* We leave the left empty for now  */
+        std::move(current)          /* We add everything to the right   */
+    ));
+};
+
 /* <|!!|> The left will be left empty (nullptr) */
-auto updateExprWithInfixOperator = [throwUnexpectedToken](IrExpression *&current,
-                                                          Token tok) -> void {
+auto updateExprWithInfixOperator = [throwUnexpectedToken, createOpElement](
+    IrExpression *&current, Token tok) -> void
+{
     /* operation -> new current, add old into right */
     if (current->isInfixOperator())
         throwUnexpectedToken(tok);
 
     current =
-        (tok.isSimple(TOKEN_LIST_ARITHMETIC_OP))
-            ? dynamic_cast<IrExpression *>(
-                  IrElement::create<IrEArithmeticOp>(nullptr, IrEArithmeticOp::getOpFromToken(tok),
-                                                     std::move(current), std::move(nullptr)))
-        : (tok.isSimple(TOKEN_LIST_LOGIC_OP))
-            ? dynamic_cast<IrExpression *>(IrElement::create<IrELogicOp>(
-                  nullptr, IrELogicOp::getOpFromToken(tok), std::move(current), std::move(nullptr)))
-        : (tok.isSimple(TOKEN_LIST_COMP_OP))
-            ? dynamic_cast<IrExpression *>(IrElement::create<IrECompOp>(
-                  nullptr, IrECompOp::getOpFromToken(tok), std::move(current), std::move(nullptr)))
-            : nullptr;
+        (tok.isSimple(TOKEN_LIST_ARITHMETIC_OP)) ? createOpElement<IrEArithmeticOp>(current, tok)
+        : (tok.isSimple(TOKEN_LIST_LOGIC_OP)) ? createOpElement<IrELogicOp>(current, tok)
+        : (tok.isSimple(TOKEN_LIST_COMP_OP)) ? createOpElement<IrECompOp>(current, tok)
+        : throw std::runtime_error("Can't create an infix operation from token " + tok.toString());
 };
 
-auto updateExprWithConstExpr = [](IrExpression *&current, Token tok) -> void {
+auto updateLeft = []<typename IrT>(IrExpression *current, IrExpression *newLeft) -> void {
+    dynamic_cast<IrT *>(current)->left = newLeft;
+    newLeft->setParent(current);
+};
+
+auto updateExprWithConstExpr = [updateLeft](IrExpression *&current, Token tok) -> void {
     IrExpression *newLeft = IrElement::create<IrEConstExpr>(current, tok);
     /* (... `op` <- currentExpression) newLeft -> currentExpression */
-    if (current != nullptr) {
+    if (current != nullptr && current->left == nullptr) {
         switch (current->type()) {
-        case Type::CompOp: dynamic_cast<IrECompOp *>(current)->left = newLeft; return;
-        case Type::ArithmeticOp: dynamic_cast<IrEArithmeticOp *>(current)->left = newLeft; return;
-        case Type::LogicOp: dynamic_cast<IrELogicOp *>(current)->left = newLeft; return;
+        case Type::CompOp: updateLeft<IrECompOp>(current, newLeft); return;
+        case Type::ArithmeticOp: updateLeft<IrEArithmeticOp>(current, newLeft); return;
+        case Type::LogicOp: updateLeft<IrELogicOp>(current, newLeft); return;
         case Type::ConstExpr:
         case Type::Call:
         case Type::VariableRef: throw std::runtime_error("Invalid expression");
         }
     }
 
+    /* Can be the case for `1 + 2 2` which is invalid */
+    else if (current != nullptr && current->left != nullptr)
+        throw std::runtime_error("Unexpected token in expression parsing: " + tok.toString());
+
     /* newLeft -> currentExpression */
     else
         current = newLeft;