From b09e2a787554c139a92946448bc3c26a8287c890 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Thu, 6 Jun 2024 23:45:27 +0800
Subject: [PATCH 1/2] :memo: update tutorial about new operators

---
 doc/tutorial.md    | 21 +++++++++++++++++++++
 doc/tutorial_zh.md | 19 +++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/doc/tutorial.md b/doc/tutorial.md
index 2cfef5a..d2af8fc 100644
--- a/doc/tutorial.md
+++ b/doc/tutorial.md
@@ -164,6 +164,27 @@ a &= 0xca;
 a |= 0xba;
 ```
 
+Operator `??` is used to check left hand side value is `nil` or not, if not,
+return the right hand side value:
+
+```javascript
+print(nil??"should get this string");
+```
+
+The example above will print `should get this string`.
+
+Operator `?.` is used to get hash member if left hand side value is not `nil`.
+And if left hand side value is not `nil` and not `hash`,
+will cause error and exit.
+
+```javascript
+var a = nil;
+print(a?.try_get); # nil
+
+var a = {try_get: "congrats!"};
+print(a?.try_get); # "congrats!"
+```
+
 ## Definition
 
 As follows.
diff --git a/doc/tutorial_zh.md b/doc/tutorial_zh.md
index b6f7070..9500456 100644
--- a/doc/tutorial_zh.md
+++ b/doc/tutorial_zh.md
@@ -159,6 +159,25 @@ a &= 0xca;
 a |= 0xba;
 ```
 
+`??` 运算符用于检查左侧值是否为 `nil`，如果不是则返回右侧的值：
+
+```javascript
+print(nil??"should get this string");
+```
+
+上面的例子会输出 `should get this string`。
+
+`?.` 运算符用于先检查左侧不为 `nil`，如果左侧不是 `nil` 则尝试获取 hash 的字段。
+当然如果左侧此时也不是 `hash` 类型，则报错退出。
+
+```javascript
+var a = nil;
+print(a?.try_get); # nil
+
+var a = {try_get: "congrats!"};
+print(a?.try_get); # "congrats!"
+```
+
 ## 定义变量
 
 如下所示。

From 0f80dd7588473701b80f0466092ccdcba56adee8 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Fri, 7 Jun 2024 00:11:54 +0800
Subject: [PATCH 2/2] :memo: rename enums

---
 src/ast_dumper.cpp    | 68 +++++++++++++++++---------------
 src/nasal_ast.h       | 68 ++++++++++++++++----------------
 src/nasal_codegen.cpp | 90 +++++++++++++++++++++----------------------
 src/nasal_parse.cpp   | 68 ++++++++++++++++----------------
 src/optimizer.cpp     | 30 +++++++--------
 5 files changed, 165 insertions(+), 159 deletions(-)

diff --git a/src/ast_dumper.cpp b/src/ast_dumper.cpp
index c570019..8cb0541 100644
--- a/src/ast_dumper.cpp
+++ b/src/ast_dumper.cpp
@@ -133,7 +133,13 @@ bool ast_dumper::visit_code_block(code_block* node) {
 
 bool ast_dumper::visit_parameter(parameter* node) {
     dump_indent();
-    std::cout << "parameter " << node->get_parameter_name();
+    std::cout << "parameter ";
+    switch(node->get_parameter_type()) {
+        case parameter::kind::normal_parameter: std::cout << "[normal]"; break;
+        case parameter::kind::dynamic_parameter: std::cout << "[dynamic]"; break;
+        case parameter::kind::default_parameter: std::cout << "[default]"; break;
+    }
+    std::cout << " " << node->get_parameter_name();
     std::cout << format_location(node);
     if (node->get_default_value()) {
         push_indent();
@@ -169,23 +175,23 @@ bool ast_dumper::visit_binary_operator(binary_operator* node) {
     dump_indent();
     std::cout << "binary_operator \"";
     switch(node->get_operator_type()) {
-        case binary_operator::binary_type::add: std::cout << "+"; break;
-        case binary_operator::binary_type::sub: std::cout << "-"; break;
-        case binary_operator::binary_type::mult: std::cout << "*"; break;
-        case binary_operator::binary_type::div: std::cout << "/"; break;
-        case binary_operator::binary_type::concat: std::cout << "~"; break;
-        case binary_operator::binary_type::bitwise_and: std::cout << "&"; break;
-        case binary_operator::binary_type::bitwise_or: std::cout << "|"; break;
-        case binary_operator::binary_type::bitwise_xor: std::cout << "^"; break;
-        case binary_operator::binary_type::cmpeq: std::cout << "=="; break;
-        case binary_operator::binary_type::cmpneq: std::cout << "!="; break;
-        case binary_operator::binary_type::grt: std::cout << ">"; break;
-        case binary_operator::binary_type::geq: std::cout << ">="; break;
-        case binary_operator::binary_type::less: std::cout << "<"; break;
-        case binary_operator::binary_type::leq: std::cout << "<="; break;
-        case binary_operator::binary_type::condition_and: std::cout << "and"; break;
-        case binary_operator::binary_type::condition_or: std::cout << "or"; break;
-        case binary_operator::binary_type::null_chain: std::cout << "??"; break;
+        case binary_operator::kind::add: std::cout << "+"; break;
+        case binary_operator::kind::sub: std::cout << "-"; break;
+        case binary_operator::kind::mult: std::cout << "*"; break;
+        case binary_operator::kind::div: std::cout << "/"; break;
+        case binary_operator::kind::concat: std::cout << "~"; break;
+        case binary_operator::kind::bitwise_and: std::cout << "&"; break;
+        case binary_operator::kind::bitwise_or: std::cout << "|"; break;
+        case binary_operator::kind::bitwise_xor: std::cout << "^"; break;
+        case binary_operator::kind::cmpeq: std::cout << "=="; break;
+        case binary_operator::kind::cmpneq: std::cout << "!="; break;
+        case binary_operator::kind::grt: std::cout << ">"; break;
+        case binary_operator::kind::geq: std::cout << ">="; break;
+        case binary_operator::kind::less: std::cout << "<"; break;
+        case binary_operator::kind::leq: std::cout << "<="; break;
+        case binary_operator::kind::condition_and: std::cout << "and"; break;
+        case binary_operator::kind::condition_or: std::cout << "or"; break;
+        case binary_operator::kind::null_chain: std::cout << "??"; break;
     }
     std::cout << "\"" << format_location(node);
     push_indent();
@@ -204,9 +210,9 @@ bool ast_dumper::visit_unary_operator(unary_operator* node) {
     dump_indent();
     std::cout << "unary_operator \"";
     switch(node->get_operator_type()) {
-        case unary_operator::unary_type::negative: std::cout << "-"; break;
-        case unary_operator::unary_type::logical_not: std::cout << "!"; break;
-        case unary_operator::unary_type::bitwise_not: std::cout << "~"; break;
+        case unary_operator::kind::negative: std::cout << "-"; break;
+        case unary_operator::kind::logical_not: std::cout << "!"; break;
+        case unary_operator::kind::bitwise_not: std::cout << "~"; break;
     }
     std::cout << "\"" << format_location(node);
     push_indent();
@@ -320,15 +326,15 @@ bool ast_dumper::visit_assignment_expr(assignment_expr* node) {
     dump_indent();
     std::cout << "assignment ";
     switch(node->get_assignment_type()) {
-        case assignment_expr::assign_type::add_equal: std::cout << "+="; break;
-        case assignment_expr::assign_type::sub_equal: std::cout << "-="; break;
-        case assignment_expr::assign_type::mult_equal: std::cout << "*="; break;
-        case assignment_expr::assign_type::div_equal: std::cout << "/="; break;
-        case assignment_expr::assign_type::concat_equal: std::cout << "~="; break;
-        case assignment_expr::assign_type::equal: std::cout << "="; break;
-        case assignment_expr::assign_type::bitwise_and_equal: std::cout << "&="; break;
-        case assignment_expr::assign_type::bitwise_or_equal: std::cout << "|="; break;
-        case assignment_expr::assign_type::bitwise_xor_equal: std::cout << "^="; break;
+        case assignment_expr::kind::add_equal: std::cout << "+="; break;
+        case assignment_expr::kind::sub_equal: std::cout << "-="; break;
+        case assignment_expr::kind::mult_equal: std::cout << "*="; break;
+        case assignment_expr::kind::div_equal: std::cout << "/="; break;
+        case assignment_expr::kind::concat_equal: std::cout << "~="; break;
+        case assignment_expr::kind::equal: std::cout << "="; break;
+        case assignment_expr::kind::bitwise_and_equal: std::cout << "&="; break;
+        case assignment_expr::kind::bitwise_or_equal: std::cout << "|="; break;
+        case assignment_expr::kind::bitwise_xor_equal: std::cout << "^="; break;
     }
     std::cout << format_location(node);
     push_indent();
@@ -428,7 +434,7 @@ bool ast_dumper::visit_iter_expr(iter_expr* node) {
 
 bool ast_dumper::visit_forei_expr(forei_expr* node) {
     dump_indent();
-    if (node->get_loop_type()==forei_expr::forei_loop_type::foreach) {
+    if (node->get_loop_type()==forei_expr::kind::foreach) {
         std::cout << "foreach";
     } else {
         std::cout << "forindex";
diff --git a/src/nasal_ast.h b/src/nasal_ast.h
index 3607e1b..1f434a5 100644
--- a/src/nasal_ast.h
+++ b/src/nasal_ast.h
@@ -240,14 +240,14 @@ public:
 
 class parameter: public expr {
 public:
-    enum class param_type {
+    enum class kind {
         normal_parameter,
         default_parameter,
         dynamic_parameter
     };
 
 private:
-    param_type type;
+    kind type;
     std::string name;
     expr* default_value;
 
@@ -256,12 +256,12 @@ public:
         expr(location, expr_type::ast_param),
         name(""), default_value(nullptr) {}
     ~parameter() override;
-    void set_parameter_type(param_type pt) {type = pt;}
+    void set_parameter_type(kind pt) {type = pt;}
     void set_parameter_name(const std::string& pname) {name = pname;}
     void set_default_value(expr* node) {default_value = node;}
-    param_type get_parameter_type() {return type;}
-    const std::string& get_parameter_name() const {return name;}
-    expr* get_default_value() {return default_value;}
+    auto get_parameter_type() {return type;}
+    const auto& get_parameter_name() const {return name;}
+    auto get_default_value() {return default_value;}
     void accept(ast_visitor*) override;
 };
 
@@ -287,7 +287,7 @@ public:
 
 class binary_operator: public expr {
 public:
-    enum class binary_type {
+    enum class kind {
         add,
         sub,
         mult,
@@ -308,7 +308,7 @@ public:
     };
 
 private:
-    binary_type type;
+    kind type;
     expr* left;
     expr* right;
     number_literal* optimized_const_number;
@@ -321,29 +321,29 @@ public:
         optimized_const_number(nullptr),
         optimized_const_string(nullptr) {}
     ~binary_operator() override;
-    void set_operator_type(binary_type operator_type) {type = operator_type;}
+    void set_operator_type(kind operator_type) {type = operator_type;}
     void set_left(expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
     void set_optimized_number(number_literal* node) {optimized_const_number = node;}
     void set_optimized_string(string_literal* node) {optimized_const_string = node;}
-    binary_type get_operator_type() const {return type;}
-    expr* get_left() {return left;}
-    expr* get_right() {return right;}
-    number_literal* get_optimized_number() {return optimized_const_number;}
-    string_literal* get_optimized_string() {return optimized_const_string;}
+    auto get_operator_type() const {return type;}
+    auto get_left() {return left;}
+    auto get_right() {return right;}
+    auto get_optimized_number() {return optimized_const_number;}
+    auto get_optimized_string() {return optimized_const_string;}
     void accept(ast_visitor*) override;
 };
 
 class unary_operator: public expr {
 public:
-    enum class unary_type {
+    enum class kind {
         negative,
         logical_not,
         bitwise_not
     };
 
 private:
-    unary_type type;
+    kind type;
     expr* value;
     number_literal* optimized_number;
 
@@ -352,12 +352,12 @@ public:
         expr(location, expr_type::ast_unary),
         value(nullptr), optimized_number(nullptr) {}
     ~unary_operator() override;
-    void set_operator_type(unary_type operator_type) {type = operator_type;}
+    void set_operator_type(kind operator_type) {type = operator_type;}
     void set_value(expr* node) {value = node;}
     void set_optimized_number(number_literal* node) {optimized_number = node;}
-    unary_type get_operator_type() const {return type;}
-    expr* get_value() {return value;}
-    number_literal* get_optimized_number() {return optimized_number;}
+    auto get_operator_type() const {return type;}
+    auto get_value() {return value;}
+    auto get_optimized_number() {return optimized_number;}
     void accept(ast_visitor*) override;
 };
 
@@ -473,7 +473,7 @@ public:
 
 class assignment_expr: public expr {
 public:
-    enum class assign_type {
+    enum class kind {
         equal,
         add_equal,
         sub_equal,
@@ -486,7 +486,7 @@ public:
     };
 
 private:
-    assign_type type;
+    kind type;
     expr* left;
     expr* right;
 
@@ -495,12 +495,12 @@ public:
         expr(location, expr_type::ast_assign),
         left(nullptr), right(nullptr) {}
     ~assignment_expr() override;
-    void set_assignment_type(assign_type operator_type) {type = operator_type;}
+    void set_assignment_type(kind operator_type) {type = operator_type;}
     void set_left(expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
-    assign_type get_assignment_type() const {return type;}
-    expr* get_left() {return left;}
-    expr* get_right() {return right;}
+    auto get_assignment_type() const {return type;}
+    auto get_left() {return left;}
+    auto get_right() {return right;}
     void accept(ast_visitor*) override;
 };
 
@@ -611,13 +611,13 @@ public:
 
 class forei_expr: public expr {
 public:
-    enum class forei_loop_type {
+    enum class kind {
         foreach,
         forindex
     };
 
 private:
-    forei_loop_type type;
+    kind type;
     iter_expr* iterator;
     expr* vector_node;
     code_block* block;
@@ -625,17 +625,17 @@ private:
 public:
     forei_expr(const span& location):
         expr(location, expr_type::ast_forei),
-        type(forei_loop_type::foreach), iterator(nullptr),
+        type(kind::foreach), iterator(nullptr),
         vector_node(nullptr), block(nullptr) {}
     ~forei_expr() override;
-    void set_loop_type(forei_loop_type ft) {type = ft;}
+    void set_loop_type(kind ft) {type = ft;}
     void set_iterator(iter_expr* node) {iterator = node;}
     void set_value(expr* node) {vector_node = node;}
     void set_code_block(code_block* node) {block = node;}
-    forei_loop_type get_loop_type() const {return type;}
-    iter_expr* get_iterator() {return iterator;}
-    expr* get_value() {return vector_node;}
-    code_block* get_code_block() {return block;}
+    auto get_loop_type() const {return type;}
+    auto get_iterator() {return iterator;}
+    auto get_value() {return vector_node;}
+    auto get_code_block() {return block;}
     void accept(ast_visitor*) override;
 };
 
diff --git a/src/nasal_codegen.cpp b/src/nasal_codegen.cpp
index 3873733..9209a96 100644
--- a/src/nasal_codegen.cpp
+++ b/src/nasal_codegen.cpp
@@ -209,16 +209,16 @@ void codegen::func_gen(function* node) {
     std::unordered_map<std::string, bool> argname;
     for(auto tmp : node->get_parameter_list()) {
         if (tmp->get_parameter_type()==
-            parameter::param_type::default_parameter) {
+            parameter::kind::default_parameter) {
             checked_default = true;
         } else if (tmp->get_parameter_type()==
-            parameter::param_type::dynamic_parameter) {
+            parameter::kind::dynamic_parameter) {
             checked_dynamic = true;
         }
         // check default parameter and dynamic parameter
         if (checked_default &&
             tmp->get_parameter_type()!=
-            parameter::param_type::default_parameter) {
+            parameter::kind::default_parameter) {
             die("must use default parameter here",
                 tmp->get_location()
             );
@@ -262,14 +262,14 @@ void codegen::func_gen(function* node) {
         }
         regist_string(name);
         switch(tmp->get_parameter_type()) {
-            case parameter::param_type::normal_parameter:
+            case parameter::kind::normal_parameter:
                 emit(op_para, const_string_map.at(name), tmp->get_location());
                 break;
-            case parameter::param_type::default_parameter:
+            case parameter::kind::default_parameter:
                 calc_gen(tmp->get_default_value());
                 emit(op_deft, const_string_map.at(name), tmp->get_location());
                 break;
-            case parameter::param_type::dynamic_parameter:
+            case parameter::kind::dynamic_parameter:
                 emit(op_dyn, const_string_map.at(name), tmp->get_location());
                 break;
         }
@@ -603,12 +603,12 @@ void codegen::definition_gen(definition_expr* node) {
 
 void codegen::assignment_expression(assignment_expr* node) {
     switch(node->get_assignment_type()) {
-        case assignment_expr::assign_type::equal:
+        case assignment_expr::kind::equal:
             calc_gen(node->get_right());
             mcall(node->get_left());
             emit(op_meq, 0, node->get_location());
             break;
-        case assignment_expr::assign_type::add_equal:
+        case assignment_expr::kind::add_equal:
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
             }
@@ -622,7 +622,7 @@ void codegen::assignment_expression(assignment_expr* node) {
                 emit(op_addeqc, const_number_map[num], node->get_location());
             }
             break;
-        case assignment_expr::assign_type::sub_equal:
+        case assignment_expr::kind::sub_equal:
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
             }
@@ -636,7 +636,7 @@ void codegen::assignment_expression(assignment_expr* node) {
                 emit(op_subeqc, const_number_map[num], node->get_location());
             }
             break;
-        case assignment_expr::assign_type::mult_equal:
+        case assignment_expr::kind::mult_equal:
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
             }
@@ -650,7 +650,7 @@ void codegen::assignment_expression(assignment_expr* node) {
                 emit(op_muleqc, const_number_map[num], node->get_location());
             }
             break;
-        case assignment_expr::assign_type::div_equal:
+        case assignment_expr::kind::div_equal:
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
             }
@@ -664,7 +664,7 @@ void codegen::assignment_expression(assignment_expr* node) {
                 emit(op_diveqc, const_number_map[num], node->get_location());
             }
             break;
-        case assignment_expr::assign_type::concat_equal:
+        case assignment_expr::kind::concat_equal:
             if (node->get_right()->get_type()!=expr_type::ast_str) {
                 calc_gen(node->get_right());
             }
@@ -678,17 +678,17 @@ void codegen::assignment_expression(assignment_expr* node) {
                 emit(op_lnkeqc, const_string_map[str], node->get_location());
             }
             break;
-        case assignment_expr::assign_type::bitwise_and_equal:
+        case assignment_expr::kind::bitwise_and_equal:
             calc_gen(node->get_right());
             mcall(node->get_left());
             emit(op_btandeq, 0, node->get_location());
             break;
-        case assignment_expr::assign_type::bitwise_or_equal:
+        case assignment_expr::kind::bitwise_or_equal:
             calc_gen(node->get_right());
             mcall(node->get_left());
             emit(op_btoreq, 0, node->get_location());
             break;
-        case assignment_expr::assign_type::bitwise_xor_equal:
+        case assignment_expr::kind::bitwise_xor_equal:
             calc_gen(node->get_right());
             mcall(node->get_left());
             emit(op_btxoreq, 0, node->get_location());
@@ -740,17 +740,17 @@ void codegen::replace_left_assignment_with_load(const span& location) {
 
 void codegen::assignment_statement(assignment_expr* node) {
     switch(node->get_assignment_type()) {
-        case assignment_expr::assign_type::equal:
+        case assignment_expr::kind::equal:
             gen_assignment_equal_statement(node);
             break;
-        case assignment_expr::assign_type::add_equal:
-        case assignment_expr::assign_type::sub_equal:
-        case assignment_expr::assign_type::mult_equal:
-        case assignment_expr::assign_type::div_equal:
-        case assignment_expr::assign_type::concat_equal:
-        case assignment_expr::assign_type::bitwise_and_equal:
-        case assignment_expr::assign_type::bitwise_or_equal:
-        case assignment_expr::assign_type::bitwise_xor_equal:
+        case assignment_expr::kind::add_equal:
+        case assignment_expr::kind::sub_equal:
+        case assignment_expr::kind::mult_equal:
+        case assignment_expr::kind::div_equal:
+        case assignment_expr::kind::concat_equal:
+        case assignment_expr::kind::bitwise_and_equal:
+        case assignment_expr::kind::bitwise_or_equal:
+        case assignment_expr::kind::bitwise_xor_equal:
             calc_gen(node);
             if (op_addeq<=code.back().op && code.back().op<=op_btxoreq) {
                 code.back().num = 1;
@@ -920,7 +920,7 @@ void codegen::forei_gen(forei_expr* node) {
     calc_gen(node->get_value());
     emit(op_cnt, 0, node->get_value()->get_location());
     usize loop_begin = code.size();
-    if (node->get_loop_type()==forei_expr::forei_loop_type::forindex) {
+    if (node->get_loop_type()==forei_expr::kind::forindex) {
         emit(op_findex, 0, node->get_location());
     } else {
         emit(op_feach, 0, node->get_location());
@@ -1032,11 +1032,11 @@ void codegen::unary_gen(unary_operator* node) {
 
     calc_gen(node->get_value());
     switch(node->get_operator_type()) {
-        case unary_operator::unary_type::negative:
+        case unary_operator::kind::negative:
             emit(op_usub, 0, node->get_location()); break;
-        case unary_operator::unary_type::logical_not:
+        case unary_operator::kind::logical_not:
             emit(op_lnot, 0, node->get_location()); break;
-        case unary_operator::unary_type::bitwise_not:
+        case unary_operator::kind::bitwise_not:
             emit(op_bnot, 0, node->get_location()); break;
     }
 }
@@ -1053,43 +1053,43 @@ void codegen::binary_gen(binary_operator* node) {
     }
 
     switch(node->get_operator_type()) {
-        case binary_operator::binary_type::condition_or: or_gen(node); return;
-        case binary_operator::binary_type::condition_and: and_gen(node); return;
+        case binary_operator::kind::condition_or: or_gen(node); return;
+        case binary_operator::kind::condition_and: and_gen(node); return;
         default: break;
     }
     switch(node->get_operator_type()) {
-        case binary_operator::binary_type::cmpeq:
+        case binary_operator::kind::cmpeq:
             calc_gen(node->get_left());
             calc_gen(node->get_right());
             emit(op_eq, 0, node->get_location());
             return;
-        case binary_operator::binary_type::cmpneq:
+        case binary_operator::kind::cmpneq:
             calc_gen(node->get_left());
             calc_gen(node->get_right());
             emit(op_neq, 0, node->get_location());
             return;
-        case binary_operator::binary_type::bitwise_or:
+        case binary_operator::kind::bitwise_or:
             calc_gen(node->get_left());
             calc_gen(node->get_right());
             emit(op_btor, 0, node->get_location());
             return;
-        case binary_operator::binary_type::bitwise_xor:
+        case binary_operator::kind::bitwise_xor:
             calc_gen(node->get_left());
             calc_gen(node->get_right());
             emit(op_btxor, 0, node->get_location());
             return;
-        case binary_operator::binary_type::bitwise_and:
+        case binary_operator::kind::bitwise_and:
             calc_gen(node->get_left());
             calc_gen(node->get_right());
             emit(op_btand, 0, node->get_location());
             return;
-        case binary_operator::binary_type::null_chain:
+        case binary_operator::kind::null_chain:
             null_chain_gen(node);
             return;
         default: break;
     }
     switch(node->get_operator_type()) {
-        case binary_operator::binary_type::add:
+        case binary_operator::kind::add:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
@@ -1101,7 +1101,7 @@ void codegen::binary_gen(binary_operator* node) {
                 emit(op_addc, const_number_map.at(num), node->get_location());
             }
             return;
-        case binary_operator::binary_type::sub:
+        case binary_operator::kind::sub:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
@@ -1113,7 +1113,7 @@ void codegen::binary_gen(binary_operator* node) {
                 emit(op_subc, const_number_map.at(num), node->get_location());
             }
             return;
-        case binary_operator::binary_type::mult:
+        case binary_operator::kind::mult:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
@@ -1125,7 +1125,7 @@ void codegen::binary_gen(binary_operator* node) {
                 emit(op_mulc, const_number_map.at(num), node->get_location());
             }
             return;
-        case binary_operator::binary_type::div:
+        case binary_operator::kind::div:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
@@ -1137,7 +1137,7 @@ void codegen::binary_gen(binary_operator* node) {
                 emit(op_divc, const_number_map.at(num), node->get_location());
             }
             return;
-        case binary_operator::binary_type::concat:
+        case binary_operator::kind::concat:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_str) {
                 calc_gen(node->get_right());
@@ -1149,7 +1149,7 @@ void codegen::binary_gen(binary_operator* node) {
                 emit(op_lnkc, const_string_map.at(str), node->get_location());
             }
             break;
-        case binary_operator::binary_type::less:
+        case binary_operator::kind::less:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
@@ -1161,7 +1161,7 @@ void codegen::binary_gen(binary_operator* node) {
                 emit(op_lessc, const_number_map.at(num), node->get_location());
             }
             return;
-        case binary_operator::binary_type::leq:
+        case binary_operator::kind::leq:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
@@ -1173,7 +1173,7 @@ void codegen::binary_gen(binary_operator* node) {
                 emit(op_leqc, const_number_map.at(num), node->get_location());
             }
             return;
-        case binary_operator::binary_type::grt:
+        case binary_operator::kind::grt:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
@@ -1185,7 +1185,7 @@ void codegen::binary_gen(binary_operator* node) {
                 emit(op_grtc, const_number_map.at(num), node->get_location());
             }
             return;
-        case binary_operator::binary_type::geq:
+        case binary_operator::kind::geq:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
diff --git a/src/nasal_parse.cpp b/src/nasal_parse.cpp
index e6ea255..0776fb4 100644
--- a/src/nasal_parse.cpp
+++ b/src/nasal_parse.cpp
@@ -347,13 +347,13 @@ void parse::params(function* func_node) {
         match(tok::tk_id);
         if (lookahead(tok::tk_eq)) {
             match(tok::tk_eq);
-            param->set_parameter_type(parameter::param_type::default_parameter);
+            param->set_parameter_type(parameter::kind::default_parameter);
             param->set_default_value(calc());
         } else if (lookahead(tok::tk_ellipsis)) {
             match(tok::tk_ellipsis);
-            param->set_parameter_type(parameter::param_type::dynamic_parameter);
+            param->set_parameter_type(parameter::kind::dynamic_parameter);
         } else {
-            param->set_parameter_type(parameter::param_type::normal_parameter);
+            param->set_parameter_type(parameter::kind::normal_parameter);
         }
         update_location(param);
         func_node->add_parameter(param);
@@ -462,12 +462,12 @@ expr* parse::calc() {
     } else if (tok::tk_eq<=toks[ptr].type && toks[ptr].type<=tok::tk_lnkeq) {
         auto tmp = new assignment_expr(toks[ptr].loc);
         switch(toks[ptr].type) {
-            case tok::tk_eq: tmp->set_assignment_type(assignment_expr::assign_type::equal); break;
-            case tok::tk_addeq: tmp->set_assignment_type(assignment_expr::assign_type::add_equal); break;
-            case tok::tk_subeq: tmp->set_assignment_type(assignment_expr::assign_type::sub_equal); break;
-            case tok::tk_multeq: tmp->set_assignment_type(assignment_expr::assign_type::mult_equal); break;
-            case tok::tk_diveq: tmp->set_assignment_type(assignment_expr::assign_type::div_equal); break;
-            case tok::tk_lnkeq: tmp->set_assignment_type(assignment_expr::assign_type::concat_equal); break;
+            case tok::tk_eq: tmp->set_assignment_type(assignment_expr::kind::equal); break;
+            case tok::tk_addeq: tmp->set_assignment_type(assignment_expr::kind::add_equal); break;
+            case tok::tk_subeq: tmp->set_assignment_type(assignment_expr::kind::sub_equal); break;
+            case tok::tk_multeq: tmp->set_assignment_type(assignment_expr::kind::mult_equal); break;
+            case tok::tk_diveq: tmp->set_assignment_type(assignment_expr::kind::div_equal); break;
+            case tok::tk_lnkeq: tmp->set_assignment_type(assignment_expr::kind::concat_equal); break;
             default: break;
         }
         tmp->set_left(node);
@@ -479,9 +479,9 @@ expr* parse::calc() {
                toks[ptr].type==tok::tk_btxoreq) {
         auto tmp = new assignment_expr(toks[ptr].loc);
         switch(toks[ptr].type) {
-            case tok::tk_btandeq: tmp->set_assignment_type(assignment_expr::assign_type::bitwise_and_equal); break;
-            case tok::tk_btoreq: tmp->set_assignment_type(assignment_expr::assign_type::bitwise_or_equal); break;
-            case tok::tk_btxoreq: tmp->set_assignment_type(assignment_expr::assign_type::bitwise_xor_equal); break;
+            case tok::tk_btandeq: tmp->set_assignment_type(assignment_expr::kind::bitwise_and_equal); break;
+            case tok::tk_btoreq: tmp->set_assignment_type(assignment_expr::kind::bitwise_or_equal); break;
+            case tok::tk_btxoreq: tmp->set_assignment_type(assignment_expr::kind::bitwise_xor_equal); break;
             default: break;
         }
         tmp->set_left(node);
@@ -497,7 +497,7 @@ expr* parse::bitwise_or() {
     auto node = bitwise_xor();
     while(lookahead(tok::tk_btor)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_operator_type(binary_operator::binary_type::bitwise_or);
+        tmp->set_operator_type(binary_operator::kind::bitwise_or);
         tmp->set_left(node);
         match(tok::tk_btor);
         tmp->set_right(bitwise_xor());
@@ -512,7 +512,7 @@ expr* parse::bitwise_xor() {
     auto node = bitwise_and();
     while(lookahead(tok::tk_btxor)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_operator_type(binary_operator::binary_type::bitwise_xor);
+        tmp->set_operator_type(binary_operator::kind::bitwise_xor);
         tmp->set_left(node);
         match(tok::tk_btxor);
         tmp->set_right(bitwise_and());
@@ -527,7 +527,7 @@ expr* parse::bitwise_and() {
     auto node = or_expr();
     while(lookahead(tok::tk_btand)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_operator_type(binary_operator::binary_type::bitwise_and);
+        tmp->set_operator_type(binary_operator::kind::bitwise_and);
         tmp->set_left(node);
         match(tok::tk_btand);
         tmp->set_right(or_expr());
@@ -542,7 +542,7 @@ expr* parse::or_expr() {
     auto node = and_expr();
     while(lookahead(tok::tk_or)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_operator_type(binary_operator::binary_type::condition_or);
+        tmp->set_operator_type(binary_operator::kind::condition_or);
         tmp->set_left(node);
         match(tok::tk_or);
         tmp->set_right(and_expr());
@@ -557,7 +557,7 @@ expr* parse::and_expr() {
     auto node = cmp_expr();
     while(lookahead(tok::tk_and)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_operator_type(binary_operator::binary_type::condition_and);
+        tmp->set_operator_type(binary_operator::kind::condition_and);
         tmp->set_left(node);
         match(tok::tk_and);
         tmp->set_right(cmp_expr());
@@ -573,12 +573,12 @@ expr* parse::cmp_expr() {
     while(tok::tk_cmpeq<=toks[ptr].type && toks[ptr].type<=tok::tk_geq) {
         auto tmp = new binary_operator(toks[ptr].loc);
         switch(toks[ptr].type) {
-            case tok::tk_cmpeq: tmp->set_operator_type(binary_operator::binary_type::cmpeq); break;
-            case tok::tk_neq: tmp->set_operator_type(binary_operator::binary_type::cmpneq); break;
-            case tok::tk_less: tmp->set_operator_type(binary_operator::binary_type::less); break;
-            case tok::tk_leq: tmp->set_operator_type(binary_operator::binary_type::leq); break;
-            case tok::tk_grt: tmp->set_operator_type(binary_operator::binary_type::grt); break;
-            case tok::tk_geq: tmp->set_operator_type(binary_operator::binary_type::geq); break;
+            case tok::tk_cmpeq: tmp->set_operator_type(binary_operator::kind::cmpeq); break;
+            case tok::tk_neq: tmp->set_operator_type(binary_operator::kind::cmpneq); break;
+            case tok::tk_less: tmp->set_operator_type(binary_operator::kind::less); break;
+            case tok::tk_leq: tmp->set_operator_type(binary_operator::kind::leq); break;
+            case tok::tk_grt: tmp->set_operator_type(binary_operator::kind::grt); break;
+            case tok::tk_geq: tmp->set_operator_type(binary_operator::kind::geq); break;
             default: break;
         }
         tmp->set_left(node);
@@ -595,7 +595,7 @@ expr* parse::null_chain_expr() {
     auto node = additive_expr();
     while(lookahead(tok::tk_quesques)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_operator_type(binary_operator::binary_type::null_chain);
+        tmp->set_operator_type(binary_operator::kind::null_chain);
         tmp->set_left(node);
         match(tok::tk_quesques);
         tmp->set_right(additive_expr());
@@ -613,9 +613,9 @@ expr* parse::additive_expr() {
           lookahead(tok::tk_floater)) {
         auto tmp = new binary_operator(toks[ptr].loc);
         switch(toks[ptr].type) {
-            case tok::tk_add: tmp->set_operator_type(binary_operator::binary_type::add); break;
-            case tok::tk_sub: tmp->set_operator_type(binary_operator::binary_type::sub); break;
-            case tok::tk_floater: tmp->set_operator_type(binary_operator::binary_type::concat); break;
+            case tok::tk_add: tmp->set_operator_type(binary_operator::kind::add); break;
+            case tok::tk_sub: tmp->set_operator_type(binary_operator::kind::sub); break;
+            case tok::tk_floater: tmp->set_operator_type(binary_operator::kind::concat); break;
             default: break;
         }
         tmp->set_left(node);
@@ -635,9 +635,9 @@ expr* parse::multive_expr() {
     while(lookahead(tok::tk_mult) || lookahead(tok::tk_div)) {
         auto tmp = new binary_operator(toks[ptr].loc);
         if (lookahead(tok::tk_mult)) {
-            tmp->set_operator_type(binary_operator::binary_type::mult);
+            tmp->set_operator_type(binary_operator::kind::mult);
         } else {
-            tmp->set_operator_type(binary_operator::binary_type::div);
+            tmp->set_operator_type(binary_operator::kind::div);
         }
         tmp->set_left(node);
         match(toks[ptr].type);
@@ -657,15 +657,15 @@ unary_operator* parse::unary() {
     auto node = new unary_operator(toks[ptr].loc);
     switch(toks[ptr].type) {
         case tok::tk_sub:
-            node->set_operator_type(unary_operator::unary_type::negative);
+            node->set_operator_type(unary_operator::kind::negative);
             match(tok::tk_sub);
             break;
         case tok::tk_not:
-            node->set_operator_type(unary_operator::unary_type::logical_not);
+            node->set_operator_type(unary_operator::kind::logical_not);
             match(tok::tk_not);
             break;
         case tok::tk_floater:
-            node->set_operator_type(unary_operator::unary_type::bitwise_not);
+            node->set_operator_type(unary_operator::kind::bitwise_not);
             match(tok::tk_floater);
             break;
         default: break;
@@ -1018,11 +1018,11 @@ forei_expr* parse::forei_loop() {
     auto node = new forei_expr(toks[ptr].loc);
     switch(toks[ptr].type) {
         case tok::tk_forindex:
-            node->set_loop_type(forei_expr::forei_loop_type::forindex);
+            node->set_loop_type(forei_expr::kind::forindex);
             match(tok::tk_forindex);
             break;
         case tok::tk_foreach: 
-            node->set_loop_type(forei_expr::forei_loop_type::foreach);
+            node->set_loop_type(forei_expr::kind::foreach);
             match(tok::tk_foreach);
             break;
         default: break;
diff --git a/src/optimizer.cpp b/src/optimizer.cpp
index 357f0f5..073cf47 100644
--- a/src/optimizer.cpp
+++ b/src/optimizer.cpp
@@ -6,7 +6,7 @@ void optimizer::const_string(
     binary_operator* node,
     string_literal* left_node,
     string_literal* right_node) {
-    if (node->get_operator_type()!=binary_operator::binary_type::concat) {
+    if (node->get_operator_type()!=binary_operator::kind::concat) {
         return;
     }
     const auto& left = left_node->get_content();
@@ -24,19 +24,19 @@ void optimizer::const_number(
     const auto right = right_node->get_number();
     f64 res;
     switch(node->get_operator_type()) {
-        case binary_operator::binary_type::add: res = left+right; break;
-        case binary_operator::binary_type::sub: res = left-right; break;
-        case binary_operator::binary_type::mult: res = left*right; break;
-        case binary_operator::binary_type::div: res = left/right; break;
-        case binary_operator::binary_type::less: res = left<right; break;
-        case binary_operator::binary_type::leq: res = left<=right; break;
-        case binary_operator::binary_type::grt: res = left>right; break;
-        case binary_operator::binary_type::geq: res = left>=right; break;
-        case binary_operator::binary_type::bitwise_or:
+        case binary_operator::kind::add: res = left+right; break;
+        case binary_operator::kind::sub: res = left-right; break;
+        case binary_operator::kind::mult: res = left*right; break;
+        case binary_operator::kind::div: res = left/right; break;
+        case binary_operator::kind::less: res = left<right; break;
+        case binary_operator::kind::leq: res = left<=right; break;
+        case binary_operator::kind::grt: res = left>right; break;
+        case binary_operator::kind::geq: res = left>=right; break;
+        case binary_operator::kind::bitwise_or:
             res = static_cast<i32>(left)|static_cast<i32>(right); break;
-        case binary_operator::binary_type::bitwise_xor:
+        case binary_operator::kind::bitwise_xor:
             res = static_cast<i32>(left)^static_cast<i32>(right); break;
-        case binary_operator::binary_type::bitwise_and:
+        case binary_operator::kind::bitwise_and:
             res = static_cast<i32>(left)&static_cast<i32>(right); break;
         default: return;
     }
@@ -53,11 +53,11 @@ void optimizer::const_number(
     number_literal* value_node) {
     auto res = value_node->get_number();
     switch(node->get_operator_type()) {
-        case unary_operator::unary_type::negative:
+        case unary_operator::kind::negative:
             res = -res; break;
-        case unary_operator::unary_type::bitwise_not:
+        case unary_operator::kind::bitwise_not:
             res = ~static_cast<i32>(res); break;
-        case unary_operator::unary_type::logical_not:
+        case unary_operator::kind::logical_not:
             res = !res; break;
     }
     if (std::isinf(res) || std::isnan(res)) {