diff --git a/src/language/ASTBuilder.cpp b/src/language/ASTBuilder.cpp
index 3e51cda195c13be9ba0901b504aa2c045eff63f8..be1a9d9664a29b453d2bd73ffd05da3748fd039b 100644
--- a/src/language/ASTBuilder.cpp
+++ b/src/language/ASTBuilder.cpp
@@ -99,14 +99,24 @@ struct ASTBuilder::simplify_unary : parse_tree::apply<ASTBuilder::simplify_unary
         n = std::move(unary_operator);
         n->remove_content();
         transform(n, st...);
-      } else if (n->children[1]->is<language::post_minusminus>() or n->children[1]->is<language::post_plusplus>()) {
-        n->remove_content();
-        auto expression     = std::move(n->children[0]);
-        auto unary_operator = std::move(n->children[1]);
-        unary_operator->children.emplace_back(std::move(expression));
-        n = std::move(unary_operator);
-        n->remove_content();
-        transform(n, st...);
+      }
+    }
+
+    if (n->is<language::unary_expression>()) {
+      size_t child_nb = n->children.size();
+      if (child_nb > 1) {
+        if (n->children[child_nb - 1]->is<language::post_minusminus>() or
+            n->children[child_nb - 1]->is<language::post_plusplus>()) {
+          auto unary_operator = std::move(n->children[child_nb - 1]);
+          n->children.pop_back();
+
+          unary_operator->remove_content();
+          unary_operator->children.emplace_back(std::move(n));
+
+          n = std::move(unary_operator);
+          n->remove_content();
+          transform(n->children[0], st...);
+        }
       }
     }
   }
@@ -203,68 +213,69 @@ struct ASTBuilder::simplify_stream_statement : parse_tree::apply<ASTBuilder::sim
 };
 
 template <typename Rule>
-using selector =
-  parse_tree::selector<Rule,
-                       parse_tree::store_content::on<import_instruction,
-                                                     module_name,
-                                                     true_kw,
-                                                     false_kw,
-                                                     integer,
-                                                     real,
-                                                     literal,
-                                                     name,
-                                                     name_list,
-                                                     expression_list,
-                                                     B_set,
-                                                     N_set,
-                                                     Z_set,
-                                                     R_set,
-                                                     string_type,
-                                                     cout_kw,
-                                                     cerr_kw,
-                                                     clog_kw,
-                                                     declaration,
-                                                     let_declaration,
-                                                     type_mapping,
-                                                     function_definition,
-                                                     if_statement,
-                                                     do_while_statement,
-                                                     while_statement,
-                                                     for_statement,
-                                                     break_kw,
-                                                     continue_kw>,
-                       ASTBuilder::rearrange::on<logical_or, logical_and, bitwise_xor, equality, compare, sum, product, affectation, expression>,
-                       ASTBuilder::simplify_unary::
-                         on<unary_minus, unary_plus, unary_not, function_evaluation, type_expression, unary_expression>,
-                       parse_tree::remove_content::on<plus_op,
-                                                      minus_op,
-                                                      multiply_op,
-                                                      divide_op,
-                                                      lesser_op,
-                                                      lesser_or_eq_op,
-                                                      greater_op,
-                                                      greater_or_eq_op,
-                                                      eqeq_op,
-                                                      not_eq_op,
-                                                      and_op,
-                                                      or_op,
-                                                      xor_op,
-                                                      eq_op,
-                                                      multiplyeq_op,
-                                                      divideeq_op,
-                                                      pluseq_op,
-                                                      minuseq_op,
-                                                      unary_plusplus,
-                                                      unary_minusminus,
-                                                      post_minusminus,
-                                                      post_plusplus>,
-                       ASTBuilder::simplify_for_statement_block::on<for_statement_block>,
-                       parse_tree::discard_empty::on<ignored, semicol, block>,
-                       ASTBuilder::simplify_statement_block::on<statement_block>,
-                       ASTBuilder::simplify_for_init::on<for_init>,
-                       ASTBuilder::simplify_for_test::on<for_test>,
-                       ASTBuilder::simplify_for_post::on<for_post>,
-                       ASTBuilder::simplify_stream_statement::on<ostream_statement>>;
+using selector = parse_tree::selector<
+  Rule,
+  parse_tree::store_content::on<import_instruction,
+                                module_name,
+                                true_kw,
+                                false_kw,
+                                integer,
+                                real,
+                                literal,
+                                name,
+                                name_list,
+                                expression_list,
+                                B_set,
+                                N_set,
+                                Z_set,
+                                R_set,
+                                string_type,
+                                cout_kw,
+                                cerr_kw,
+                                clog_kw,
+                                declaration,
+                                let_declaration,
+                                type_mapping,
+                                function_definition,
+                                if_statement,
+                                do_while_statement,
+                                while_statement,
+                                for_statement,
+                                break_kw,
+                                continue_kw>,
+  ASTBuilder::rearrange::
+    on<logical_or, logical_and, bitwise_xor, equality, compare, sum, product, affectation, expression>,
+  ASTBuilder::simplify_unary::
+    on<unary_minus, unary_plus, unary_not, function_evaluation, type_expression, unary_expression>,
+  parse_tree::remove_content::on<plus_op,
+                                 minus_op,
+                                 multiply_op,
+                                 divide_op,
+                                 lesser_op,
+                                 lesser_or_eq_op,
+                                 greater_op,
+                                 greater_or_eq_op,
+                                 eqeq_op,
+                                 not_eq_op,
+                                 and_op,
+                                 or_op,
+                                 xor_op,
+                                 eq_op,
+                                 multiplyeq_op,
+                                 divideeq_op,
+                                 pluseq_op,
+                                 minuseq_op,
+                                 unary_plusplus,
+                                 unary_minusminus,
+                                 post_minusminus,
+                                 post_plusplus>,
+  ASTBuilder::simplify_for_statement_block::on<for_statement_block>,
+  parse_tree::discard_empty::on<ignored, semicol, block>,
+  ASTBuilder::simplify_statement_block::on<statement_block>,
+  ASTBuilder::simplify_for_init::on<for_init>,
+  ASTBuilder::simplify_for_test::on<for_test>,
+  ASTBuilder::simplify_for_post::on<for_post>,
+  ASTBuilder::simplify_stream_statement::on<ostream_statement>>;
 
 template <typename InputT>
 std::unique_ptr<ASTNode>