4 files changed, 356 insertions, 356 deletions
diff --git a/src/MoonP/moon_ast.h b/src/MoonP/moon_ast.h
index 86f5ef3..4525df1 100644
--- a/src/MoonP/moon_ast.h
+++ b/src/MoonP/moon_ast.h
@@ -13,19 +13,28 @@ using namespace parserlib;
 namespace MoonP {
-#define AST_LEAF(type, id) \
+// str hash helper functions (djb2)
+inline constexpr size_t hash(char const* input) {
+        return *input ? *input + 33ull * hash(input + 1) : 5381;
+}
+template<class T>
+constexpr typename std::enable_if<std::is_base_of<ast_node,T>::value,size_t>::type
+id() { return 0; }
+#define AST_LEAF(type) \
 class type##_t : public ast_node \
 { \
 public: \
        virtual int get_type() override { return ast_type<type##_t>(); } \
-        virtual size_t getId() const override { return id; } \
+        virtual size_t getId() const override { return hash(#type); }
-#define AST_NODE(type, id) \
+#define AST_NODE(type) \
 class type##_t : public ast_container \
 { \
 public: \
        virtual int get_type() override { return ast_type<type##_t>(); } \
-        virtual size_t getId() const override { return id; } \
+        virtual size_t getId() const override { return hash(#type); } \
 #define AST_MEMBER(type, ...) \
        type##_t() { \
@@ -33,73 +42,74 @@ public: \
        }
 #define AST_END(type) \
-};
+}; \
+template<> constexpr size_t id<type##_t>() { return hash(#type); }
-AST_LEAF(Num, "Num"_id)
+AST_LEAF(Num)
 AST_END(Num)
-AST_LEAF(Name, "Name"_id)
+AST_LEAF(Name)
 AST_END(Name)
-AST_NODE(Variable, "Variable"_id)
+AST_NODE(Variable)
        ast_ptr<true, Name_t> name;
        AST_MEMBER(Variable, &name)
 AST_END(Variable)
-AST_NODE(LuaKeyword, "LuaKeyword"_id)
+AST_NODE(LuaKeyword)
        ast_ptr<true, Name_t> name;
        AST_MEMBER(LuaKeyword, &name)
 AST_END(LuaKeyword)
-AST_LEAF(self, "self"_id)
+AST_LEAF(self)
 AST_END(self)
-AST_NODE(self_name, "self_name"_id)
+AST_NODE(self_name)
        ast_ptr<true, Name_t> name;
        AST_MEMBER(self_name, &name)
 AST_END(self_name)
-AST_LEAF(self_class, "self_class"_id)
+AST_LEAF(self_class)
 AST_END(self_class)
-AST_NODE(self_class_name, "self_class_name"_id)
+AST_NODE(self_class_name)
        ast_ptr<true, Name_t> name;
        AST_MEMBER(self_class_name, &name)
 AST_END(self_class_name)
-AST_NODE(SelfName, "SelfName"_id)
+AST_NODE(SelfName)
        ast_sel<true, self_class_name_t, self_class_t, self_name_t, self_t> name;
        AST_MEMBER(SelfName, &name)
 AST_END(SelfName)
-AST_NODE(KeyName, "KeyName"_id)
+AST_NODE(KeyName)
        ast_sel<true, SelfName_t, Name_t> name;
        AST_MEMBER(KeyName, &name)
 AST_END(KeyName)
-AST_LEAF(VarArg, "VarArg"_id)
+AST_LEAF(VarArg)
 AST_END(VarArg)
-AST_LEAF(local_flag, "local_flag"_id)
+AST_LEAF(local_flag)
 AST_END(local_flag)
-AST_LEAF(Seperator, "Seperator"_id)
+AST_LEAF(Seperator)
 AST_END(Seperator)
-AST_NODE(NameList, "NameList"_id)
+AST_NODE(NameList)
        ast_ptr<true, Seperator_t> sep;
        ast_list<true, Variable_t> names;
        AST_MEMBER(NameList, &sep, &names)
 AST_END(NameList)
-AST_NODE(Local, "Local"_id)
+AST_NODE(Local)
        ast_sel<true, local_flag_t, NameList_t> name;
        std::list<std::string> forceDecls;
        std::list<std::string> decls;
        AST_MEMBER(Local, &name)
 AST_END(Local)
-AST_NODE(colon_import_name, "colon_import_name"_id)
+AST_NODE(colon_import_name)
        ast_ptr<true, Variable_t> name;
        AST_MEMBER(colon_import_name, &name)
 AST_END(colon_import_name)
@@ -107,29 +117,29 @@ AST_END(colon_import_name)
 class Exp_t;
 class TableLit_t;
-AST_LEAF(import_literal_inner, "import_literal_inner"_id)
+AST_LEAF(import_literal_inner)
 AST_END(import_literal_inner)
-AST_NODE(ImportLiteral, "ImportLiteral"_id)
+AST_NODE(ImportLiteral)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, import_literal_inner_t> inners;
        AST_MEMBER(ImportLiteral, &sep, &inners)
 AST_END(ImportLiteral)
-AST_NODE(ImportAs, "ImportAs"_id)
+AST_NODE(ImportAs)
        ast_ptr<true, ImportLiteral_t> literal;
        ast_sel<false, Variable_t, TableLit_t> target;
        AST_MEMBER(ImportAs, &literal, &target)
 AST_END(ImportAs)
-AST_NODE(ImportFrom, "ImportFrom"_id)
+AST_NODE(ImportFrom)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, colon_import_name_t, Variable_t> names;
        ast_ptr<true, Exp_t> exp;
        AST_MEMBER(ImportFrom, &sep, &names, &exp)
 AST_END(ImportFrom)
-AST_NODE(Import, "Import"_id)
+AST_NODE(Import)
        ast_sel<true, ImportAs_t, ImportFrom_t> content;
        AST_MEMBER(Import, &content)
 AST_END(Import)
@@ -137,25 +147,25 @@ AST_END(Import)
 class FnArgsDef_t;
 class ChainValue_t;
-AST_NODE(Backcall, "Backcall"_id)
+AST_NODE(Backcall)
        ast_ptr<false, FnArgsDef_t> argsDef;
        ast_ptr<true, ChainValue_t> value;
        AST_MEMBER(Backcall, &argsDef, &value)
 AST_END(Backcall)
-AST_NODE(ExpListLow, "ExpListLow"_id)
+AST_NODE(ExpListLow)
        ast_ptr<true, Seperator_t> sep;
        ast_list<true, Exp_t> exprs;
        AST_MEMBER(ExpListLow, &sep, &exprs)
 AST_END(ExpListLow)
-AST_NODE(ExpList, "ExpList"_id)
+AST_NODE(ExpList)
        ast_ptr<true, Seperator_t> sep;
        ast_list<true, Exp_t> exprs;
        AST_MEMBER(ExpList, &sep, &exprs)
 AST_END(ExpList)
-AST_NODE(Return, "Return"_id)
+AST_NODE(Return)
        ast_ptr<false, ExpListLow_t> valueList;
        AST_MEMBER(Return, &valueList)
 AST_END(Return)
@@ -163,20 +173,20 @@ AST_END(Return)
 class Assign_t;
 class Body_t;
-AST_NODE(With, "With"_id)
+AST_NODE(With)
        ast_ptr<true, ExpList_t> valueList;
        ast_ptr<false, Assign_t> assigns;
        ast_ptr<true, Body_t> body;
        AST_MEMBER(With, &valueList, &assigns, &body)
 AST_END(With)
-AST_NODE(SwitchCase, "SwitchCase"_id)
+AST_NODE(SwitchCase)
        ast_ptr<true, ExpList_t> valueList;
        ast_ptr<true, Body_t> body;
        AST_MEMBER(SwitchCase, &valueList, &body)
 AST_END(SwitchCase)
-AST_NODE(Switch, "Switch"_id)
+AST_NODE(Switch)
        ast_ptr<true, Exp_t> target;
        ast_ptr<true, Seperator_t> sep;
        ast_list<true, SwitchCase_t> branches;
@@ -184,36 +194,36 @@ AST_NODE(Switch, "Switch"_id)
        AST_MEMBER(Switch, &target, &sep, &branches, &lastBranch)
 AST_END(Switch)
-AST_NODE(IfCond, "IfCond"_id)
+AST_NODE(IfCond)
        ast_ptr<true, Exp_t> condition;
        ast_ptr<false, Assign_t> assign;
        AST_MEMBER(IfCond, &condition, &assign)
 AST_END(IfCond)
-AST_NODE(If, "If"_id)
+AST_NODE(If)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, IfCond_t, Body_t> nodes;
        AST_MEMBER(If, &sep, &nodes)
 AST_END(If)
-AST_NODE(Unless, "Unless"_id)
+AST_NODE(Unless)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, IfCond_t, Body_t> nodes;
        AST_MEMBER(Unless, &sep, &nodes)
 AST_END(Unless)
-AST_NODE(While, "While"_id)
+AST_NODE(While)
        ast_ptr<true, Exp_t> condition;
        ast_ptr<true, Body_t> body;
        AST_MEMBER(While, &condition, &body)
 AST_END(While)
-AST_NODE(for_step_value, "for_step_value"_id)
+AST_NODE(for_step_value)
        ast_ptr<true, Exp_t> value;
        AST_MEMBER(for_step_value, &value)
 AST_END(for_step_value)
-AST_NODE(For, "For"_id)
+AST_NODE(For)
        ast_ptr<true, Variable_t> varName;
        ast_ptr<true, Exp_t> startValue;
        ast_ptr<true, Exp_t> stopValue;
@@ -225,14 +235,14 @@ AST_END(For)
 class AssignableNameList_t;
 class star_exp_t;
-AST_NODE(ForEach, "ForEach"_id)
+AST_NODE(ForEach)
        ast_ptr<true, AssignableNameList_t> nameList;
        ast_sel<true, star_exp_t, ExpList_t> loopValue;
        ast_ptr<true, Body_t> body;
        AST_MEMBER(ForEach, &nameList, &loopValue, &body)
 AST_END(ForEach)
-AST_NODE(Do, "Do"_id)
+AST_NODE(Do)
        ast_ptr<true, Body_t> body;
        AST_MEMBER(Do, &body)
 AST_END(Do)
@@ -240,36 +250,36 @@ AST_END(Do)
 class CompInner_t;
 class Statement_t;
-AST_NODE(Comprehension, "Comprehension"_id)
+AST_NODE(Comprehension)
        ast_sel<true, Exp_t, Statement_t> value;
        ast_ptr<true, CompInner_t> forLoop;
        AST_MEMBER(Comprehension, &value, &forLoop)
 AST_END(Comprehension)
-AST_NODE(comp_value, "comp_value"_id)
+AST_NODE(comp_value)
        ast_ptr<true, Exp_t> value;
        AST_MEMBER(comp_value, &value)
 AST_END(comp_value)
-AST_NODE(TblComprehension, "TblComprehension"_id)
+AST_NODE(TblComprehension)
        ast_ptr<true, Exp_t> key;
        ast_ptr<false, comp_value_t> value;
        ast_ptr<true, CompInner_t> forLoop;
        AST_MEMBER(TblComprehension, &key, &value, &forLoop)
 AST_END(TblComprehension)
-AST_NODE(star_exp, "star_exp"_id)
+AST_NODE(star_exp)
        ast_ptr<true, Exp_t> value;
        AST_MEMBER(star_exp, &value)
 AST_END(star_exp)
-AST_NODE(CompForEach, "CompForEach"_id)
+AST_NODE(CompForEach)
        ast_ptr<true, AssignableNameList_t> nameList;
        ast_sel<true, star_exp_t, Exp_t> loopValue;
        AST_MEMBER(CompForEach, &nameList, &loopValue)
 AST_END(CompForEach)
-AST_NODE(CompFor, "CompFor"_id)
+AST_NODE(CompFor)
        ast_ptr<true, Variable_t> varName;
        ast_ptr<true, Exp_t> startValue;
        ast_ptr<true, Exp_t> stopValue;
@@ -277,7 +287,7 @@ AST_NODE(CompFor, "CompFor"_id)
        AST_MEMBER(CompFor, &varName, &startValue, &stopValue, &stepValue)
 AST_END(CompFor)
-AST_NODE(CompInner, "CompInner"_id)
+AST_NODE(CompInner)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, CompFor_t, CompForEach_t, Exp_t> items;
        AST_MEMBER(CompInner, &sep, &items)
@@ -285,43 +295,43 @@ AST_END(CompInner)
 class TableBlock_t;
-AST_NODE(Assign, "Assign"_id)
+AST_NODE(Assign)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, With_t, If_t, Switch_t, TableBlock_t, Exp_t> values;
        AST_MEMBER(Assign, &sep, &values)
 AST_END(Assign)
-AST_LEAF(update_op, "update_op"_id)
+AST_LEAF(update_op)
 AST_END(update_op)
-AST_NODE(Update, "Update"_id)
+AST_NODE(Update)
        ast_ptr<true, update_op_t> op;
        ast_ptr<true, Exp_t> value;
        AST_MEMBER(Update, &op, &value)
 AST_END(Update)
-AST_LEAF(BinaryOperator, "BinaryOperator"_id)
+AST_LEAF(BinaryOperator)
 AST_END(BinaryOperator)
-AST_LEAF(BackcallOperator, "BackcallOperator"_id)
+AST_LEAF(BackcallOperator)
 AST_END(BackcallOperator)
 class AssignableChain_t;
-AST_NODE(Assignable, "Assignable"_id)
+AST_NODE(Assignable)
        ast_sel<true, AssignableChain_t, Variable_t, SelfName_t> item;
        AST_MEMBER(Assignable, &item)
 AST_END(Assignable)
 class Value_t;
-AST_NODE(exp_op_value, "exp_op_value"_id)
+AST_NODE(exp_op_value)
        ast_sel<true, BinaryOperator_t, BackcallOperator_t> op;
        ast_ptr<true, Value_t> value;
        AST_MEMBER(exp_op_value, &op, &value)
 AST_END(exp_op_value)
-AST_NODE(Exp, "Exp"_id)
+AST_NODE(Exp)
        ast_ptr<true, Value_t> value;
        ast_list<false, exp_op_value_t> opValues;
        AST_MEMBER(Exp, &value, &opValues)
@@ -329,12 +339,12 @@ AST_END(Exp)
 class Parens_t;
-AST_NODE(Callable, "Callable"_id)
+AST_NODE(Callable)
        ast_sel<true, Variable_t, SelfName_t, VarArg_t, Parens_t> item;
        AST_MEMBER(Callable, &item)
 AST_END(Callable)
-AST_NODE(variable_pair, "variable_pair"_id)
+AST_NODE(variable_pair)
        ast_ptr<true, Variable_t> name;
        AST_MEMBER(variable_pair, &name)
 AST_END(variable_pair)
@@ -342,13 +352,13 @@ AST_END(variable_pair)
 class DoubleString_t;
 class SingleString_t;
-AST_NODE(normal_pair, "normal_pair"_id)
+AST_NODE(normal_pair)
        ast_sel<true, KeyName_t, Exp_t, DoubleString_t, SingleString_t> key;
        ast_sel<true, Exp_t, TableBlock_t> value;
        AST_MEMBER(normal_pair, &key, &value)
 AST_END(normal_pair)
-AST_NODE(simple_table, "simple_table"_id)
+AST_NODE(simple_table)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, variable_pair_t, normal_pair_t> pairs;
        AST_MEMBER(simple_table, &sep, &pairs)
@@ -361,7 +371,7 @@ class unary_exp_t;
 class TableLit_t;
 class FunLit_t;
-AST_NODE(SimpleValue, "SimpleValue"_id)
+AST_NODE(SimpleValue)
        ast_sel<true, const_value_t,
        If_t, Unless_t, Switch_t, With_t, ClassDecl_t,
        ForEach_t, For_t, While_t, Do_t, unary_exp_t,
@@ -370,50 +380,50 @@ AST_NODE(SimpleValue, "SimpleValue"_id)
        AST_MEMBER(SimpleValue, &value)
 AST_END(SimpleValue)
-AST_LEAF(LuaStringOpen, "LuaStringOpen"_id)
+AST_LEAF(LuaStringOpen)
 AST_END(LuaStringOpen)
-AST_LEAF(LuaStringContent, "LuaStringContent"_id)
+AST_LEAF(LuaStringContent)
 AST_END(LuaStringContent)
-AST_LEAF(LuaStringClose, "LuaStringClose"_id)
+AST_LEAF(LuaStringClose)
 AST_END(LuaStringClose)
-AST_NODE(LuaString, "LuaString"_id)
+AST_NODE(LuaString)
        ast_ptr<true, LuaStringOpen_t> open;
        ast_ptr<true, LuaStringContent_t> content;
        ast_ptr<true, LuaStringClose_t> close;
        AST_MEMBER(LuaString, &open, &content, &close)
 AST_END(LuaString)
-AST_LEAF(SingleString, "SingleString"_id)
+AST_LEAF(SingleString)
 AST_END(SingleString)
-AST_LEAF(double_string_inner, "double_string_inner"_id)
+AST_LEAF(double_string_inner)
 AST_END(double_string_inner)
-AST_NODE(double_string_content, "double_string_content"_id)
+AST_NODE(double_string_content)
        ast_sel<true, double_string_inner_t, Exp_t> content;
        AST_MEMBER(double_string_content, &content)
 AST_END(double_string_content)
-AST_NODE(DoubleString, "DoubleString"_id)
+AST_NODE(DoubleString)
        ast_ptr<true, Seperator_t> sep;
        ast_list<false, double_string_content_t> segments;
        AST_MEMBER(DoubleString, &sep, &segments)
 AST_END(DoubleString)
-AST_NODE(String, "String"_id)
+AST_NODE(String)
        ast_sel<true, DoubleString_t, SingleString_t, LuaString_t> str;
        AST_MEMBER(String, &str)
 AST_END(String)
-AST_NODE(DotChainItem, "DotChainItem"_id)
+AST_NODE(DotChainItem)
        ast_ptr<true, Name_t> name;
        AST_MEMBER(DotChainItem, &name)
 AST_END(DotChainItem)
-AST_NODE(ColonChainItem, "ColonChainItem"_id)
+AST_NODE(ColonChainItem)
        ast_sel<true, LuaKeyword_t, Name_t> name;
        bool switchToDot = false;
        AST_MEMBER(ColonChainItem, &name)
@@ -421,180 +431,180 @@ AST_END(ColonChainItem)
 class default_value_t;
-AST_NODE(Slice, "Slice"_id)
+AST_NODE(Slice)
        ast_sel<true, Exp_t, default_value_t> startValue;
        ast_sel<true, Exp_t, default_value_t> stopValue;
        ast_sel<true, Exp_t, default_value_t> stepValue;
        AST_MEMBER(Slice, &startValue, &stopValue, &stepValue)
 AST_END(Slice)
-AST_NODE(Parens, "Parens"_id)
+AST_NODE(Parens)
        ast_ptr<true, Exp_t> expr;
        AST_MEMBER(Parens, &expr)
 AST_END(Parens)
-AST_NODE(Invoke, "Invoke"_id)
+AST_NODE(Invoke)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<false, Exp_t, SingleString_t, DoubleString_t, LuaString_t> args;
        AST_MEMBER(Invoke, &sep, &args)
 AST_END(Invoke)
-AST_LEAF(existential_op, "existential_op"_id)
+AST_LEAF(existential_op)
 AST_END(existential_op)
 class InvokeArgs_t;
-AST_NODE(ChainValue, "ChainValue"_id)
+AST_NODE(ChainValue)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, Callable_t, Invoke_t, DotChainItem_t, ColonChainItem_t, Slice_t, Exp_t, String_t, InvokeArgs_t, existential_op_t> items;
        AST_MEMBER(ChainValue, &sep, &items)
 AST_END(ChainValue)
-AST_NODE(AssignableChain, "AssignableChain"_id)
+AST_NODE(AssignableChain)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, Callable_t, Invoke_t, DotChainItem_t, ColonChainItem_t, Exp_t, String_t> items;
        AST_MEMBER(AssignableChain, &sep, &items)
 AST_END(AssignableChain)
-AST_NODE(Value, "Value"_id)
+AST_NODE(Value)
        ast_sel<true, SimpleValue_t, simple_table_t, ChainValue_t, String_t> item;
        AST_MEMBER(Value, &item)
 AST_END(Value)
-AST_LEAF(default_value, "default_value"_id)
+AST_LEAF(default_value)
 AST_END(default_value)
-AST_NODE(TableLit, "TableLit"_id)
+AST_NODE(TableLit)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<false, variable_pair_t, normal_pair_t, Exp_t> values;
        AST_MEMBER(TableLit, &sep, &values)
 AST_END(TableLit)
-AST_NODE(TableBlock, "TableBlock"_id)
+AST_NODE(TableBlock)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<false, variable_pair_t, normal_pair_t> values;
        AST_MEMBER(TableBlock, &sep, &values)
 AST_END(TableBlock)
-AST_NODE(class_member_list, "class_member_list"_id)
+AST_NODE(class_member_list)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, variable_pair_t, normal_pair_t> values;
        AST_MEMBER(class_member_list, &sep, &values)
 AST_END(class_member_list)
-AST_NODE(ClassBlock, "ClassBlock"_id)
+AST_NODE(ClassBlock)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, class_member_list_t, Statement_t> contents;
        AST_MEMBER(ClassBlock, &sep, &contents)
 AST_END(ClassBlock)
-AST_NODE(ClassDecl, "ClassDecl"_id)
+AST_NODE(ClassDecl)
        ast_ptr<false, Assignable_t> name;
        ast_ptr<false, Exp_t> extend;
        ast_ptr<false, ClassBlock_t> body;
        AST_MEMBER(ClassDecl, &name, &extend, &body)
 AST_END(ClassDecl)
-AST_NODE(export_values, "export_values"_id)
+AST_NODE(export_values)
        ast_ptr<true, NameList_t> nameList;
        ast_ptr<false, ExpListLow_t> valueList;
        AST_MEMBER(export_values, &nameList, &valueList)
 AST_END(export_values)
-AST_LEAF(export_op, "export_op"_id)
+AST_LEAF(export_op)
 AST_END(export_op)
-AST_NODE(Export, "Export"_id)
+AST_NODE(Export)
        ast_sel<true, ClassDecl_t, export_op_t, export_values_t> item;
        AST_MEMBER(Export, &item)
 AST_END(Export)
-AST_NODE(FnArgDef, "FnArgDef"_id)
+AST_NODE(FnArgDef)
        ast_sel<true, Variable_t, SelfName_t> name;
        ast_ptr<false, Exp_t> defaultValue;
        AST_MEMBER(FnArgDef, &name, &defaultValue)
 AST_END(FnArgDef)
-AST_NODE(FnArgDefList, "FnArgDefList"_id)
+AST_NODE(FnArgDefList)
        ast_ptr<true, Seperator_t> sep;
        ast_list<false, FnArgDef_t> definitions;
        ast_ptr<false, VarArg_t> varArg;
        AST_MEMBER(FnArgDefList, &sep, &definitions, &varArg)
 AST_END(FnArgDefList)
-AST_NODE(outer_var_shadow, "outer_var_shadow"_id)
+AST_NODE(outer_var_shadow)
        ast_ptr<false, NameList_t> varList;
        AST_MEMBER(outer_var_shadow, &varList)
 AST_END(outer_var_shadow)
-AST_NODE(FnArgsDef, "FnArgsDef"_id)
+AST_NODE(FnArgsDef)
        ast_ptr<false, FnArgDefList_t> defList;
        ast_ptr<false, outer_var_shadow_t> shadowOption;
        AST_MEMBER(FnArgsDef, &defList, &shadowOption)
 AST_END(FnArgsDef)
-AST_LEAF(fn_arrow, "fn_arrow"_id)
+AST_LEAF(fn_arrow)
 AST_END(fn_arrow)
-AST_NODE(FunLit, "FunLit"_id)
+AST_NODE(FunLit)
        ast_ptr<false, FnArgsDef_t> argsDef;
        ast_ptr<true, fn_arrow_t> arrow;
        ast_ptr<false, Body_t> body;
        AST_MEMBER(FunLit, &argsDef, &arrow, &body)
 AST_END(FunLit)
-AST_NODE(NameOrDestructure, "NameOrDestructure"_id)
+AST_NODE(NameOrDestructure)
        ast_sel<true, Variable_t, TableLit_t> item;
        AST_MEMBER(NameOrDestructure, &item)
 AST_END(NameOrDestructure)
-AST_NODE(AssignableNameList, "AssignableNameList"_id)
+AST_NODE(AssignableNameList)
        ast_ptr<true, Seperator_t> sep;
        ast_list<true, NameOrDestructure_t> items;
        AST_MEMBER(AssignableNameList, &sep, &items)
 AST_END(AssignableNameList)
-AST_NODE(InvokeArgs, "InvokeArgs"_id)
+AST_NODE(InvokeArgs)
        ast_ptr<true, Seperator_t> sep;
        ast_sel_list<true, Exp_t, TableBlock_t> args;
        AST_MEMBER(InvokeArgs, &sep, &args)
 AST_END(InvokeArgs)
-AST_LEAF(const_value, "const_value"_id)
+AST_LEAF(const_value)
 AST_END(const_value)
-AST_NODE(unary_exp, "unary_exp"_id)
+AST_NODE(unary_exp)
        ast_ptr<true, Exp_t> item;
        AST_MEMBER(unary_exp, &item)
 AST_END(unary_exp)
-AST_NODE(ExpListAssign, "ExpListAssign"_id)
+AST_NODE(ExpListAssign)
        ast_ptr<true, ExpList_t> expList;
        ast_sel<false, Update_t, Assign_t> action;
        AST_MEMBER(ExpListAssign, &expList, &action)
 AST_END(ExpListAssign)
-AST_NODE(if_else_line, "if_else_line"_id)
+AST_NODE(if_else_line)
        ast_ptr<true, Exp_t> condition;
        ast_ptr<false, Assign_t> assign;
        ast_sel<false, Exp_t, default_value_t> elseExpr;
        AST_MEMBER(if_else_line, &condition, &assign, &elseExpr)
 AST_END(if_else_line)
-AST_NODE(unless_line, "unless_line"_id)
+AST_NODE(unless_line)
        ast_ptr<true, Exp_t> condition;
        AST_MEMBER(unless_line, &condition)
 AST_END(unless_line)
-AST_NODE(statement_appendix, "statement_appendix"_id)
+AST_NODE(statement_appendix)
        ast_sel<true, if_else_line_t, unless_line_t, CompInner_t> item;
        AST_MEMBER(statement_appendix, &item)
 AST_END(statement_appendix)
-AST_LEAF(BreakLoop, "BreakLoop"_id)
+AST_LEAF(BreakLoop)
 AST_END(BreakLoop)
-AST_NODE(Statement, "Statement"_id)
+AST_NODE(Statement)
        ast_sel<true, Import_t, While_t, For_t, ForEach_t,
                Return_t, Local_t, Export_t, BreakLoop_t,
                Backcall_t, ExpListAssign_t> content;
@@ -604,20 +614,21 @@ AST_END(Statement)
 class Block_t;
-AST_NODE(Body, "Body"_id)
+AST_NODE(Body)
        ast_sel<true, Block_t, Statement_t> content;
        AST_MEMBER(Body, &content)
 AST_END(Body)
-AST_NODE(Block, "Block"_id)
+AST_NODE(Block)
        ast_ptr<true, Seperator_t> sep;
        ast_list<false, Statement_t> statements;
        AST_MEMBER(Block, &sep, &statements)
 AST_END(Block)
-AST_NODE(File, "File"_id)
+AST_NODE(File)
        ast_ptr<true, Block_t> block;
        AST_MEMBER(File, &block)
 AST_END(File)
 } // namespace MoonP
diff --git a/src/MoonP/moon_compiler.cpp b/src/MoonP/moon_compiler.cpp
index 4406dbd..fa55496 100644
--- a/src/MoonP/moon_compiler.cpp
+++ b/src/MoonP/moon_compiler.cpp
@@ -314,17 +314,17 @@ private:
        Value_t* singleValueFrom(ast_node* item) const {
                Exp_t* exp = nullptr;
                switch (item->getId()) {
-                        case "Exp"_id:
+                        case id<Exp_t>():
                                exp = static_cast<Exp_t*>(item);
                                break;
-                        case "ExpList"_id: {
+                        case id<ExpList_t>(): {
                                auto expList = static_cast<ExpList_t*>(item);
                                if (expList->exprs.size() == 1) {
                                        exp = static_cast<Exp_t*>(expList->exprs.front());
                                }
                                break;
                        }
-                        case "ExpListLow"_id: {
+                        case id<ExpListLow_t>(): {
                                auto expList = static_cast<ExpListLow_t*>(item);
                                if (expList->exprs.size() == 1) {
                                        exp = static_cast<Exp_t*>(expList->exprs.front());
@@ -459,18 +459,18 @@ private:
                         auto firstItem = chainItems.back();
                         if (auto callable = ast_cast<Callable_t>(firstItem)) {
                                 switch (callable->item->getId()) {
-                                         case "Variable"_id:
+                                         case id<Variable_t>():
-                                         case "SelfName"_id:
+                                         case id<SelfName_t>():
                                                 return true;
                                 }
-                         } else if (firstItem->getId() == "DotChainItem"_id) {
+                         } else if (firstItem->getId() == id<DotChainItem_t>()) {
                                 return true;
                         }
                 } else {
                        auto lastItem = chainItems.back();
                        switch (lastItem->getId()) {
-                                case "DotChainItem"_id:
+                                case id<DotChainItem_t>():
-                                case "Exp"_id:
+                                case id<Exp_t>():
                                        return true;
                        }
                }
@@ -481,16 +481,16 @@ private:
                if (auto value = singleValueFrom(exp)) {
                        auto item = value->item.get();
                        switch (item->getId()) {
-                                case "simple_table"_id:
+                                case id<simple_table_t>():
                                        return true;
-                                case "SimpleValue"_id: {
+                                case id<SimpleValue_t>(): {
                                        auto simpleValue = static_cast<SimpleValue_t*>(item);
                                        if (simpleValue->value. is<TableLit_t>()) {
                                                return true;
                                        }
                                        return false;
                                }
-                                case "ChainValue"_id: {
+                                case id<ChainValue_t>(): {
                                        auto chainValue = static_cast<ChainValue_t*>(item);
                                        return isAssignable(chainValue->items.objects());
                                }
@@ -539,7 +539,7 @@ private:
                        }
                        auto appendix = statement->appendix.get();
                        switch (appendix->item->getId()) {
-                                case "if_else_line"_id: {
+                                case id<if_else_line_t>(): {
                                        auto if_else_line = appendix->item.to<if_else_line_t>();
                                        auto ifNode = x->new_ptr<If_t>();
@@ -580,7 +580,7 @@ private:
                                        statement->content.set(expListAssign);
                                        break;
                                }
-                                case "unless_line"_id: {
+                                case id<unless_line_t>(): {
                                        auto unless_line = appendix->item.to<unless_line_t>();
                                        auto unless = x->new_ptr<Unless_t>();
@@ -608,7 +608,7 @@ private:
                                        statement->content.set(expListAssign);
                                        break;
                                }
-                                case "CompInner"_id: {
+                                case id<CompInner_t>(): {
                                        auto compInner = appendix->item.to<CompInner_t>();
                                        auto comp = x->new_ptr<Comprehension_t>();
                                        comp->forLoop.set(compInner);
@@ -629,7 +629,7 @@ private:
                                        statement->appendix.set(nullptr);
                                        break;
                                }
-                                default: break;
+                                default: assert(false); break;
                        }
                }
                auto content = statement->content.get();
@@ -638,15 +638,15 @@ private:
                        return;
                }
                switch (content->getId()) {
-                        case "Import"_id: transformImport(static_cast<Import_t*>(content), out); break;
+                        case id<Import_t>(): transformImport(static_cast<Import_t*>(content), out); break;
-                        case "While"_id: transformWhile(static_cast<While_t*>(content), out); break;
+                        case id<While_t>(): transformWhile(static_cast<While_t*>(content), out); break;
-                        case "For"_id: transformFor(static_cast<For_t*>(content), out); break;
+                        case id<For_t>(): transformFor(static_cast<For_t*>(content), out); break;
-                        case "ForEach"_id: transformForEach(static_cast<ForEach_t*>(content), out); break;
+                        case id<ForEach_t>(): transformForEach(static_cast<ForEach_t*>(content), out); break;
-                        case "Return"_id: transformReturn(static_cast<Return_t*>(content), out); break;
+                        case id<Return_t>(): transformReturn(static_cast<Return_t*>(content), out); break;
-                        case "Local"_id: transformLocal(static_cast<Local_t*>(content), out); break;
+                        case id<Local_t>(): transformLocal(static_cast<Local_t*>(content), out); break;
-                        case "Export"_id: transformExport(static_cast<Export_t*>(content), out); break;
+                        case id<Export_t>(): transformExport(static_cast<Export_t*>(content), out); break;
-                        case "BreakLoop"_id: transformBreakLoop(static_cast<BreakLoop_t*>(content), out); break;
+                        case id<BreakLoop_t>(): transformBreakLoop(static_cast<BreakLoop_t*>(content), out); break;
-                        case "ExpListAssign"_id: {
+                        case id<ExpListAssign_t>(): {
                                auto expListAssign = static_cast<ExpListAssign_t*>(content);
                                if (expListAssign->action) {
                                        transformAssignment(expListAssign, out);
@@ -661,16 +661,16 @@ private:
                                                        auto value = simpleValue->value.get();
                                                        bool specialSingleValue = true;
                                                        switch (value->getId()) {
-                                                                case "If"_id: transformIf(static_cast<If_t*>(value), out, ExpUsage::Common); break;
+                                                                case id<If_t>(): transformIf(static_cast<If_t*>(value), out, ExpUsage::Common); break;
-                                                                case "ClassDecl"_id: transformClassDecl(static_cast<ClassDecl_t*>(value), out, ExpUsage::Common); break;
+                                                                case id<ClassDecl_t>(): transformClassDecl(static_cast<ClassDecl_t*>(value), out, ExpUsage::Common); break;
-                                                                case "Unless"_id: transformUnless(static_cast<Unless_t*>(value), out, ExpUsage::Common); break;
+                                                                case id<Unless_t>(): transformUnless(static_cast<Unless_t*>(value), out, ExpUsage::Common); break;
-                                                                case "Switch"_id: transformSwitch(static_cast<Switch_t*>(value), out, ExpUsage::Common); break;
+                                                                case id<Switch_t>(): transformSwitch(static_cast<Switch_t*>(value), out, ExpUsage::Common); break;
-                                                                case "With"_id: transformWith(static_cast<With_t*>(value), out); break;
+                                                                case id<With_t>(): transformWith(static_cast<With_t*>(value), out); break;
-                                                                case "ForEach"_id: transformForEach(static_cast<ForEach_t*>(value), out); break;
+                                                                case id<ForEach_t>(): transformForEach(static_cast<ForEach_t*>(value), out); break;
-                                                                case "For"_id: transformFor(static_cast<For_t*>(value), out); break;
+                                                                case id<For_t>(): transformFor(static_cast<For_t*>(value), out); break;
-                                                                case "While"_id: transformWhile(static_cast<While_t*>(value), out); break;
+                                                                case id<While_t>(): transformWhile(static_cast<While_t*>(value), out); break;
-                                                                case "Do"_id: transformDo(static_cast<Do_t*>(value), out, ExpUsage::Common); break;
+                                                                case id<Do_t>(): transformDo(static_cast<Do_t*>(value), out, ExpUsage::Common); break;
-                                                                case "Comprehension"_id: transformCompCommon(static_cast<Comprehension_t*>(value), out); break;
+                                                                case id<Comprehension_t>(): transformCompCommon(static_cast<Comprehension_t*>(value), out); break;
                                                                default: specialSingleValue = false; break;
                                                        }
                                                        if (specialSingleValue) {
@@ -694,7 +694,7 @@ private:
                                }
                                break;
                        }
-                        default: break;
+                        default: assert(false); break;
                }
        }
@@ -834,20 +834,20 @@ private:
                        }
                }
                switch (value->getId()) {
-                        case "If"_id:
+                        case id<If_t>():
-                        case "Unless"_id: {
+                        case id<Unless_t>(): {
                                auto expList = assignment->expList.get();
                                str_list temp;
                                auto defs = transformAssignDefs(expList);
                                if (!defs.empty()) temp.push_back(getPredefine(defs) + nll(expList));
                                switch (value->getId()) {
-                                        case "If"_id: transformIf(static_cast<If_t*>(value), temp, ExpUsage::Assignment, expList); break;
+                                        case id<If_t>(): transformIf(static_cast<If_t*>(value), temp, ExpUsage::Assignment, expList); break;
-                                        case "Unless"_id: transformUnless(static_cast<Unless_t*>(value), temp, ExpUsage::Assignment, expList); break;
+                                        case id<Unless_t>(): transformUnless(static_cast<Unless_t*>(value), temp, ExpUsage::Assignment, expList); break;
                                }
                                out.push_back(join(temp));
                                return;
                        }
-                        case "Switch"_id: {
+                        case id<Switch_t>(): {
                                auto switchNode = static_cast<Switch_t*>(value);
                                auto assignList = assignment->expList.get();
                                std::string preDefine = getPredefine(assignment);
@@ -855,7 +855,7 @@ private:
                                out.back().insert(0, preDefine.empty() ? Empty : preDefine + nll(assignment));
                                return;
                        }
-                        case "With"_id: {
+                        case id<With_t>(): {
                                auto withNode = static_cast<With_t*>(value);
                                auto expList = assignment->expList.get();
                                std::string preDefine = getPredefine(assignment);
@@ -863,7 +863,7 @@ private:
                                out.back().insert(0, preDefine.empty() ? Empty : preDefine + nll(assignment));
                                return;
                        }
-                        case "Do"_id: {
+                        case id<Do_t>(): {
                                auto expList = assignment->expList.get();
                                auto doNode = static_cast<Do_t*>(value);
                                std::string preDefine = getPredefine(assignment);
@@ -871,42 +871,42 @@ private:
                                out.back().insert(0, preDefine.empty() ? Empty : preDefine + nll(assignment));
                                return;
                        }
-                        case "Comprehension"_id: {
+                        case id<Comprehension_t>(): {
                                auto expList = assignment->expList.get();
                                std::string preDefine = getPredefine(assignment);
                                transformComprehension(static_cast<Comprehension_t*>(value), out, ExpUsage::Assignment, expList);
                                out.back().insert(0, preDefine.empty() ? Empty : preDefine + nll(assignment));
                                return;
                        }
-                        case "TblComprehension"_id: {
+                        case id<TblComprehension_t>(): {
                                auto expList = assignment->expList.get();
                                std::string preDefine = getPredefine(assignment);
                                transformTblComprehension(static_cast<TblComprehension_t*>(value), out, ExpUsage::Assignment, expList);
                                out.back().insert(0, preDefine.empty() ? Empty : preDefine + nll(assignment));
                                return;
                        }
-                        case "For"_id: {
+                        case id<For_t>(): {
                                auto expList = assignment->expList.get();
                                std::string preDefine = getPredefine(assignment);
                                transformForInPlace(static_cast<For_t*>(value), out, expList);
                                out.back().insert(0, preDefine.empty() ? Empty : preDefine + nll(assignment));
                                return;
                        }
-                        case "ForEach"_id: {
+                        case id<ForEach_t>(): {
                                auto expList = assignment->expList.get();
                                std::string preDefine = getPredefine(assignment);
                                transformForEachInPlace(static_cast<ForEach_t*>(value), out, expList);
                                out.back().insert(0, preDefine.empty() ? Empty : preDefine + nll(assignment));
                                return;
                        }
-                        case "ClassDecl"_id: {
+                        case id<ClassDecl_t>(): {
                                auto expList = assignment->expList.get();
                                std::string preDefine = getPredefine(assignment);
                                transformClassDecl(static_cast<ClassDecl_t*>(value), out, ExpUsage::Assignment, expList);
                                out.back().insert(0, preDefine.empty() ? Empty : preDefine + nll(assignment));
                                return;
                        }
-                        case "While"_id: {
+                        case id<While_t>(): {
                                auto expList = assignment->expList.get();
                                std::string preDefine = getPredefine(assignment);
                                transformWhileInPlace(static_cast<While_t*>(value), out, expList);
@@ -1006,12 +1006,12 @@ private:
        void transformAssignItem(ast_node* value, str_list& out) {
                switch (value->getId()) {
-                        case "With"_id: transformWithClosure(static_cast<With_t*>(value), out); break;
+                        case id<With_t>(): transformWithClosure(static_cast<With_t*>(value), out); break;
-                        case "If"_id: transformIf(static_cast<If_t*>(value), out, ExpUsage::Closure); break;
+                        case id<If_t>(): transformIf(static_cast<If_t*>(value), out, ExpUsage::Closure); break;
-                        case "Switch"_id: transformSwitch(static_cast<Switch_t*>(value), out, ExpUsage::Closure); break;
+                        case id<Switch_t>(): transformSwitch(static_cast<Switch_t*>(value), out, ExpUsage::Closure); break;
-                        case "TableBlock"_id: transformTableBlock(static_cast<TableBlock_t*>(value), out); break;
+                        case id<TableBlock_t>(): transformTableBlock(static_cast<TableBlock_t*>(value), out); break;
-                        case "Exp"_id: transformExp(static_cast<Exp_t*>(value), out, ExpUsage::Closure); break;
+                        case id<Exp_t>(): transformExp(static_cast<Exp_t*>(value), out, ExpUsage::Closure); break;
-                        default: break;
+                        default: assert(false); break;
                }
        }
@@ -1034,7 +1034,7 @@ private:
                int index = 0;
                for (auto pair : *tableItems) {
                        switch (pair->getId()) {
-                                case "Exp"_id: {
+                                case id<Exp_t>(): {
                                        ++index;
                                        if (!isAssignable(static_cast<Exp_t*>(pair)))  {
                                                throw std::logic_error(_info.errorMessage("Can't destructure value."sv, pair));
@@ -1068,7 +1068,7 @@ private:
                                        }
                                        break;
                                }
-                                case "variable_pair"_id: {
+                                case id<variable_pair_t>(): {
                                        auto vp = static_cast<variable_pair_t*>(pair);
                                        auto name = _parser.toString(vp->name);
                                        if (Keywords.find(name) != Keywords.end()) {
@@ -1078,7 +1078,7 @@ private:
                                        }
                                        break;
                                }
-                                case "normal_pair"_id: {
+                                case id<normal_pair_t>(): {
                                        auto np = static_cast<normal_pair_t*>(pair);
                                        auto key = np->key->getByPath<Name_t>();
                                        if (!key) throw std::logic_error(_info.errorMessage("Invalid key for destructure."sv, np));
@@ -1135,6 +1135,7 @@ private:
                                        }
                                        break;
                                }
+                                default: assert(false); break;
                        }
                }
                return pairs;
@@ -1203,7 +1204,7 @@ private:
                auto expList = assignment->expList.get();
                auto action = assignment->action.get();
                switch (action->getId()) {
-                        case "Update"_id: {
+                        case id<Update_t>(): {
                                if (expList->exprs.size() > 1) throw std::logic_error(_info.errorMessage("Can not apply update to multiple values."sv, expList));
                                auto update = static_cast<Update_t*>(action);
                                auto leftExp = static_cast<Exp_t*>(expList->exprs.objects().front());
@@ -1247,7 +1248,7 @@ private:
                                out.push_back(clearBuf());
                                break;
                        }
-                        case "Assign"_id: {
+                        case id<Assign_t>(): {
                                bool oneLined = true;
                                auto assign = static_cast<Assign_t*>(action);
                                for (auto val : assign->values.objects()) {
@@ -1292,7 +1293,7 @@ private:
                                }
                                break;
                        }
-                        default: break;
+                        default: assert(false); break;
                }
        }
@@ -1344,14 +1345,14 @@ private:
                ifCondPairs.emplace_back();
                for (auto node : nodes) {
                        switch (node->getId()) {
-                                case "IfCond"_id:
+                                case id<IfCond_t>():
                                        ifCondPairs.back().first = static_cast<IfCond_t*>(node);
                                        break;
-                                case "Body"_id:
+                                case id<Body_t>():
                                        ifCondPairs.back().second = static_cast<Body_t*>(node);
                                        ifCondPairs.emplace_back();
                                        break;
-                                default: break;
+                                default: assert(false); break;
                        }
                }
                auto assign = ifCondPairs.front().first->assign.get();
@@ -1571,22 +1572,22 @@ private:
        void transformValue(Value_t* value, str_list& out) {
                auto item = value->item.get();
                switch (item->getId()) {
-                        case "SimpleValue"_id: transformSimpleValue(static_cast<SimpleValue_t*>(item), out); break;
+                        case id<SimpleValue_t>(): transformSimpleValue(static_cast<SimpleValue_t*>(item), out); break;
-                        case "simple_table"_id: transform_simple_table(static_cast<simple_table_t*>(item), out); break;
+                        case id<simple_table_t>(): transform_simple_table(static_cast<simple_table_t*>(item), out); break;
-                        case "ChainValue"_id: {
+                        case id<ChainValue_t>(): {
                                auto chainValue = static_cast<ChainValue_t*>(item);
                                transformChainValue(chainValue, out, ExpUsage::Closure);
                                break;
                        }
-                        case "String"_id: transformString(static_cast<String_t*>(item), out); break;
+                        case id<String_t>(): transformString(static_cast<String_t*>(item), out); break;
-                        default: break;
+                        default: assert(false); break;
                }
        }
        void transformCallable(Callable_t* callable, str_list& out, const ast_sel<false,Invoke_t,InvokeArgs_t>& invoke = {}) {
                auto item = callable->item.get();
                switch (item->getId()) {
-                        case "Variable"_id: {
+                        case id<Variable_t>(): {
                                transformVariable(static_cast<Variable_t*>(item), out);
                                if (_config.lintGlobalVariable && !isDefined(out.back())) {
                                        if (_globals.find(out.back()) == _globals.end()) {
@@ -1595,7 +1596,7 @@ private:
                                }
                                break;
                        }
-                        case "SelfName"_id: {
+                        case id<SelfName_t>(): {
                                transformSelfName(static_cast<SelfName_t*>(item), out, invoke);
                                if (_config.lintGlobalVariable) {
                                        std::string self("self"sv);
@@ -1607,9 +1608,9 @@ private:
                                }
                                break;
                        }
-                        case "VarArg"_id: out.push_back(s("..."sv)); break;
+                        case id<VarArg_t>(): out.push_back(s("..."sv)); break;
-                        case "Parens"_id: transformParens(static_cast<Parens_t*>(item), out); break;
+                        case id<Parens_t>(): transformParens(static_cast<Parens_t*>(item), out); break;
-                        default: break;
+                        default: assert(false); break;
                }
        }
@@ -1622,23 +1623,23 @@ private:
        void transformSimpleValue(SimpleValue_t* simpleValue, str_list& out) {
                auto value = simpleValue->value.get();
                switch (value->getId()) {
-                        case "const_value"_id: transform_const_value(static_cast<const_value_t*>(value), out); break;
+                        case id<const_value_t>(): transform_const_value(static_cast<const_value_t*>(value), out); break;
-                        case "If"_id: transformIf(static_cast<If_t*>(value), out, ExpUsage::Closure); break;
+                        case id<If_t>(): transformIf(static_cast<If_t*>(value), out, ExpUsage::Closure); break;
-                        case "Unless"_id: transformUnless(static_cast<Unless_t*>(value), out, ExpUsage::Closure); break;
+                        case id<Unless_t>(): transformUnless(static_cast<Unless_t*>(value), out, ExpUsage::Closure); break;
-                        case "Switch"_id: transformSwitch(static_cast<Switch_t*>(value), out, ExpUsage::Closure); break;
+                        case id<Switch_t>(): transformSwitch(static_cast<Switch_t*>(value), out, ExpUsage::Closure); break;
-                        case "With"_id: transformWithClosure(static_cast<With_t*>(value), out); break;
+                        case id<With_t>(): transformWithClosure(static_cast<With_t*>(value), out); break;
-                        case "ClassDecl"_id: transformClassDeclClosure(static_cast<ClassDecl_t*>(value), out); break;
+                        case id<ClassDecl_t>(): transformClassDeclClosure(static_cast<ClassDecl_t*>(value), out); break;
-                        case "ForEach"_id: transformForEachClosure(static_cast<ForEach_t*>(value), out); break;
+                        case id<ForEach_t>(): transformForEachClosure(static_cast<ForEach_t*>(value), out); break;
-                        case "For"_id: transformForClosure(static_cast<For_t*>(value), out); break;
+                        case id<For_t>(): transformForClosure(static_cast<For_t*>(value), out); break;
-                        case "While"_id: transformWhileClosure(static_cast<While_t*>(value), out); break;
+                        case id<While_t>(): transformWhileClosure(static_cast<While_t*>(value), out); break;
-                        case "Do"_id: transformDo(static_cast<Do_t*>(value), out, ExpUsage::Closure); break;
+                        case id<Do_t>(): transformDo(static_cast<Do_t*>(value), out, ExpUsage::Closure); break;
-                        case "unary_exp"_id: transform_unary_exp(static_cast<unary_exp_t*>(value), out); break;
+                        case id<unary_exp_t>(): transform_unary_exp(static_cast<unary_exp_t*>(value), out); break;
-                        case "TblComprehension"_id: transformTblComprehension(static_cast<TblComprehension_t*>(value), out, ExpUsage::Closure); break;
+                        case id<TblComprehension_t>(): transformTblComprehension(static_cast<TblComprehension_t*>(value), out, ExpUsage::Closure); break;
-                        case "TableLit"_id: transformTableLit(static_cast<TableLit_t*>(value), out); break;
+                        case id<TableLit_t>(): transformTableLit(static_cast<TableLit_t*>(value), out); break;
-                        case "Comprehension"_id: transformComprehension(static_cast<Comprehension_t*>(value), out, ExpUsage::Closure); break;
+                        case id<Comprehension_t>(): transformComprehension(static_cast<Comprehension_t*>(value), out, ExpUsage::Closure); break;
-                        case "FunLit"_id: transformFunLit(static_cast<FunLit_t*>(value), out); break;
+                        case id<FunLit_t>(): transformFunLit(static_cast<FunLit_t*>(value), out); break;
-                        case "Num"_id: transformNum(static_cast<Num_t*>(value), out); break;
+                        case id<Num_t>(): transformNum(static_cast<Num_t*>(value), out); break;
-                        default: break;
+                        default: assert(false); break;
                }
        }
@@ -1882,8 +1883,7 @@ private:
                                }
                                break;
                        }
-                        default:
+                        default: break;
-                                break;
                }
                if (!nodes.empty()) {
                        str_list temp;
@@ -1909,37 +1909,37 @@ private:
                                if (auto simpleValue = singleValue->item.as<SimpleValue_t>()) {
                                        auto value = simpleValue->value.get();
                                        switch (value->getId()) {
-                                                case "Comprehension"_id:
+                                                case id<Comprehension_t>():
                                                        transformComprehension(static_cast<Comprehension_t*>(value), out, ExpUsage::Return);
                                                        return;
-                                                case "TblComprehension"_id:
+                                                case id<TblComprehension_t>():
                                                        transformTblComprehension(static_cast<TblComprehension_t*>(value), out, ExpUsage::Return);
                                                        return;
-                                                case "With"_id:
+                                                case id<With_t>():
                                                        transformWith(static_cast<With_t*>(value), out, nullptr, true);
                                                        return;
-                                                case "ClassDecl"_id:
+                                                case id<ClassDecl_t>():
                                                        transformClassDecl(static_cast<ClassDecl_t*>(value), out, ExpUsage::Return);
                                                        return;
-                                                case "Do"_id:
+                                                case id<Do_t>():
                                                        transformDo(static_cast<Do_t*>(value), out, ExpUsage::Return);
                                                        return;
-                                                case "Switch"_id:
+                                                case id<Switch_t>():
                                                        transformSwitch(static_cast<Switch_t*>(value), out, ExpUsage::Return);
                                                        return;
-                                                case "While"_id:
+                                                case id<While_t>():
                                                        transformWhileInPlace(static_cast<While_t*>(value), out);
                                                        return;
-                                                case "For"_id:
+                                                case id<For_t>():
                                                        transformForInPlace(static_cast<For_t*>(value), out);
                                                        return;
-                                                case "ForEach"_id:
+                                                case id<ForEach_t>():
                                                        transformForEachInPlace(static_cast<ForEach_t*>(value), out);
                                                        return;
-                                                case "If"_id:
+                                                case id<If_t>():
                                                        transformIf(static_cast<If_t*>(value), out, ExpUsage::Return);
                                                        return;
-                                                case "Unless"_id:
+                                                case id<Unless_t>():
                                                        transformUnless(static_cast<Unless_t*>(value), out, ExpUsage::Return);
                                                        return;
                                        }
@@ -1998,34 +1998,35 @@ private:
                        auto def = static_cast<FnArgDef_t*>(_def);
                        auto& arg = argItems.emplace_back();
                        switch (def->name->getId()) {
-                                case "Variable"_id: arg.name = _parser.toString(def->name); break;
+                                case id<Variable_t>(): arg.name = _parser.toString(def->name); break;
-                                case "SelfName"_id: {
+                                case id<SelfName_t>(): {
                                        assignSelf = true;
                                        auto selfName = static_cast<SelfName_t*>(def->name.get());
                                        switch (selfName->name->getId()) {
-                                                case "self_class_name"_id: {
+                                                case id<self_class_name_t>(): {
                                                        auto clsName = static_cast<self_class_name_t*>(selfName->name.get());
                                                        arg.name = _parser.toString(clsName->name);
                                                        arg.assignSelf = s("self.__class."sv) + arg.name;
                                                        break;
                                                }
-                                                case "self_class"_id:
+                                                case id<self_class_t>():
                                                        arg.name = "self.__class"sv;
                                                        break;
-                                                case "self_name"_id: {
+                                                case id<self_name_t>(): {
                                                        auto sfName = static_cast<self_name_t*>(selfName->name.get());
                                                        arg.name = _parser.toString(sfName->name);
                                                        arg.assignSelf = s("self."sv) + arg.name;
                                                        break;
                                                }
-                                                case "self"_id:
+                                                case id<self_t>():
                                                        arg.name = "self"sv;
                                                        break;
-                                                default: break;
+                                                default: assert(false); break;
                                        }
                                        break;
                                }
+                                default: assert(false); break;
                        }
                        forceAddToScope(arg.name);
                        if (def->defaultValue) {
@@ -2075,7 +2076,7 @@ private:
                auto x = selfName;
                auto name = selfName->name.get();
                switch (name->getId()) {
-                        case "self_class_name"_id: {
+                        case id<self_class_name_t>(): {
                                auto clsName = static_cast<self_class_name_t*>(name);
                                auto nameStr = _parser.toString(clsName->name);
                                if (LuaKeywords.find(nameStr) != LuaKeywords.end()) {
@@ -2093,10 +2094,10 @@ private:
                                }
                                break;
                        }
-                        case "self_class"_id:
+                        case id<self_class_t>():
                                out.push_back(s("self.__class"sv));
                                break;
-                        case "self_name"_id: {
+                        case id<self_name_t>(): {
                                auto sfName = static_cast<self_class_name_t*>(name);
                                auto nameStr = _parser.toString(sfName->name);
                                if (LuaKeywords.find(nameStr) != LuaKeywords.end()) {
@@ -2114,9 +2115,10 @@ private:
                                }
                                break;
                        }
-                        case "self"_id:
+                        case id<self_t>():
                                out.push_back(s("self"sv));
                                break;
+                        default: assert(false); break;
                }
        }
@@ -2344,8 +2346,8 @@ private:
                        }
                        auto baseChain = x->new_ptr<ChainValue_t>();
                        switch (chainList.front()->getId()) {
-                                case "DotChainItem"_id:
+                                case id<DotChainItem_t>():
-                                case "ColonChainItem"_id:
+                                case id<ColonChainItem_t>():
                                        if (_withVars.empty()) {
                                                throw std::logic_error(_info.errorMessage("Short dot/colon syntax must be called within a with block."sv, chainList.front()));
                                        } else {
@@ -2426,8 +2428,8 @@ private:
                auto x = chainList.front();
                str_list temp;
                switch (x->getId()) {
-                        case "DotChainItem"_id:
+                        case id<DotChainItem_t>():
-                        case "ColonChainItem"_id:
+                        case id<ColonChainItem_t>():
                                if (_withVars.empty()) {
                                        throw std::logic_error(_info.errorMessage("Short dot/colon syntax must be called within a with block."sv, x));
                                } else {
@@ -2438,13 +2440,13 @@ private:
                for (auto it = chainList.begin(); it != chainList.end(); ++it) {
                        auto item = *it;
                        switch (item->getId()) {
-                                case "Invoke"_id:
+                                case id<Invoke_t>():
                                        transformInvoke(static_cast<Invoke_t*>(item), temp);
                                        break;
-                                case "DotChainItem"_id:
+                                case id<DotChainItem_t>():
                                        transformDotChainItem(static_cast<DotChainItem_t*>(item), temp);
                                        break;
-                                case "ColonChainItem"_id: {
+                                case id<ColonChainItem_t>(): {
                                        auto colonItem = static_cast<ColonChainItem_t*>(item);
                                        auto current = it;
                                        auto next = current; ++next;
@@ -2469,8 +2471,8 @@ private:
                                                {
                                                        auto chainValue = x->new_ptr<ChainValue_t>();
                                                        switch (chainList.front()->getId()) {
-                                                                case "DotChainItem"_id:
+                                                                case id<DotChainItem_t>():
-                                                                case "ColonChainItem"_id:
+                                                                case id<ColonChainItem_t>():
                                                                chainValue->items.push_back(toAst<Callable_t>(_withVars.top(), x));
                                                                        break;
                                                        }
@@ -2559,10 +2561,10 @@ private:
                                        transformColonChainItem(colonItem, temp);
                                        break;
                                }
-                                case "Slice"_id:
+                                case id<Slice_t>():
                                        transformSlice(static_cast<Slice_t*>(item), temp);
                                        break;
-                                case "Callable"_id: {
+                                case id<Callable_t>(): {
                                        auto next = it; ++next;
                                        auto followItem = next != chainList.end() ? *next : nullptr;
                                        ast_sel<false, Invoke_t, InvokeArgs_t> invoke;
@@ -2572,16 +2574,16 @@ private:
                                        transformCallable(static_cast<Callable_t*>(item), temp, invoke);
                                        break;
                                }
-                                case "String"_id:
+                                case id<String_t>():
                                        transformString(static_cast<String_t*>(item), temp);
                                        temp.back() = s("("sv) + temp.back() + s(")"sv);
                                        break;
-                                case "Exp"_id:
+                                case id<Exp_t>():
                                        transformExp(static_cast<Exp_t*>(item), temp, ExpUsage::Closure);
                                        temp.back() = s("["sv) + temp.back() + s("]"sv);
                                        break;
-                                case "InvokeArgs"_id: transformInvokeArgs(static_cast<InvokeArgs_t*>(item), temp); break;
+                                case id<InvokeArgs_t>(): transformInvokeArgs(static_cast<InvokeArgs_t*>(item), temp); break;
-                                default: break;
+                                default: assert(false); break;
                        }
                }
                switch (usage) {
@@ -2637,11 +2639,11 @@ private:
                str_list temp;
                for (auto arg : invoke->args.objects()) {
                        switch (arg->getId()) {
-                                case "Exp"_id: transformExp(static_cast<Exp_t*>(arg), temp, ExpUsage::Closure); break;
+                                case id<Exp_t>(): transformExp(static_cast<Exp_t*>(arg), temp, ExpUsage::Closure); break;
-                                case "SingleString"_id: transformSingleString(static_cast<SingleString_t*>(arg), temp); break;
+                                case id<SingleString_t>(): transformSingleString(static_cast<SingleString_t*>(arg), temp); break;
-                                case "DoubleString"_id: transformDoubleString(static_cast<DoubleString_t*>(arg), temp); break;
+                                case id<DoubleString_t>(): transformDoubleString(static_cast<DoubleString_t*>(arg), temp); break;
-                                case "LuaString"_id: transformLuaString(static_cast<LuaString_t*>(arg), temp); break;
+                                case id<LuaString_t>(): transformLuaString(static_cast<LuaString_t*>(arg), temp); break;
-                                default: break;
+                                default: assert(false); break;
                        }
                }
                out.push_back(s("("sv) + join(temp, ", "sv) + s(")"sv));
@@ -2672,17 +2674,18 @@ private:
                auto compInner = comp->forLoop.get();
                for (auto item : compInner->items.objects()) {
                        switch (item->getId()) {
-                                case "CompForEach"_id:
+                                case id<CompForEach_t>():
                                        transformCompForEach(static_cast<CompForEach_t*>(item), temp);
                                        break;
-                                case "CompFor"_id:
+                                case id<CompFor_t>():
                                        transformCompFor(static_cast<CompFor_t*>(item), temp);
                                        break;
-                                case "Exp"_id:
+                                case id<Exp_t>():
                                        transformExp(static_cast<Exp_t*>(item), temp, ExpUsage::Closure);
                                        temp.back() = indent() + s("if "sv) + temp.back() + s(" then"sv) + nll(item);
                                        pushScope();
                                        break;
+                                default: assert(false); break;
                        }
                }
                if (auto stmt = comp->value.as<Statement_t>()) {
@@ -2724,17 +2727,18 @@ private:
                auto compInner = comp->forLoop.get();
                for (auto item : compInner->items.objects()) {
                        switch (item->getId()) {
-                                case "CompForEach"_id:
+                                case id<CompForEach_t>():
                                        transformCompForEach(static_cast<CompForEach_t*>(item), temp);
                                        break;
-                                case "CompFor"_id:
+                                case id<CompFor_t>():
                                        transformCompFor(static_cast<CompFor_t*>(item), temp);
                                        break;
-                                case "Exp"_id:
+                                case id<Exp_t>():
                                        transformExp(static_cast<Exp_t*>(item), temp, ExpUsage::Closure);
                                        temp.back() = indent() + s("if "sv) + temp.back() + s(" then"sv) + nll(item);
                                        pushScope();
                                        break;
+                                default: assert(false); break;
                        }
                }
                {
@@ -2802,22 +2806,22 @@ private:
                for (auto _item : nameList->items.objects()) {
                        auto item = static_cast<NameOrDestructure_t*>(_item)->item.get();
                        switch (item->getId()) {
-                                case "Variable"_id:
+                                case id<Variable_t>():
                                        transformVariable(static_cast<Variable_t*>(item), vars);
                                        varAfter.push_back(vars.back());
                                        break;
-                                case "TableLit"_id: {
+                                case id<TableLit_t>(): {
                                        auto desVar = getUnusedName("_des_"sv);
                                        destructPairs.emplace_back(item, toAst<Exp_t>(desVar, x));
                                        vars.push_back(desVar);
                                        varAfter.push_back(desVar);
                                        break;
                                }
-                                default: break;
+                                default: assert(false); break;
                        }
                }
                switch (loopTarget->getId()) {
-                        case "star_exp"_id: {
+                        case id<star_exp_t>(): {
                                auto star_exp = static_cast<star_exp_t*>(loopTarget);
                                auto listVar = singleVariableFrom(star_exp->value);
                                auto indexVar = getUnusedName("_index_");
@@ -2902,17 +2906,17 @@ private:
                                }
                                break;
                        }
-                        case "Exp"_id:
+                        case id<Exp_t>():
                                transformExp(static_cast<Exp_t*>(loopTarget), temp, ExpUsage::Closure);
                                _buf << indent() << "for "sv << join(vars, ", "sv) << " in "sv << temp.back() << " do"sv << nlr(loopTarget);
                                out.push_back(clearBuf());
                                break;
-                        case "ExpList"_id:
+                        case id<ExpList_t>():
                                transformExpList(static_cast<ExpList_t*>(loopTarget), temp);
                                _buf << indent() << "for "sv << join(vars, ", "sv) << " in "sv << temp.back() << " do"sv << nlr(loopTarget);
                                out.push_back(clearBuf());
                                break;
-                        default: break;
+                        default: assert(false); break;
                }
                for (auto& var : varBefore) addToScope(var);
                pushScope();
@@ -2947,9 +2951,9 @@ private:
                str_list temp;
                for (auto arg : invokeArgs->args.objects()) {
                        switch (arg->getId()) {
-                                case "Exp"_id: transformExp(static_cast<Exp_t*>(arg), temp, ExpUsage::Closure); break;
+                                case id<Exp_t>(): transformExp(static_cast<Exp_t*>(arg), temp, ExpUsage::Closure); break;
-                                case "TableBlock"_id: transformTableBlock(static_cast<TableBlock_t*>(arg), temp); break;
+                                case id<TableBlock_t>(): transformTableBlock(static_cast<TableBlock_t*>(arg), temp); break;
-                                default: break;
+                                default: assert(false); break;
                        }
                }
                out.push_back(s("("sv) + join(temp, ", "sv) + s(")"sv));
@@ -2979,10 +2983,10 @@ private:
                str_list temp;
                bool withContinue = traversal::Stop == body->traverse([&](ast_node* node) {
                        switch (node->getId()) {
-                                case "For"_id:
+                                case id<For_t>():
-                                case "ForEach"_id:
+                                case id<ForEach_t>():
                                        return traversal::Return;
-                                case "BreakLoop"_id: {
+                                case id<BreakLoop_t>(): {
                                        return _parser.toString(node) == "continue"sv ?
                                                traversal::Stop : traversal::Return;
                                }
@@ -3156,31 +3160,31 @@ private:
                auto key = pair->key.get();
                str_list temp;
                switch (key->getId()) {
-                        case "KeyName"_id: {
+                        case id<KeyName_t>(): {
                                transformKeyName(static_cast<KeyName_t*>(key), temp);
                                if (LuaKeywords.find(temp.back()) != LuaKeywords.end()) {
                                        temp.back() = s("[\""sv) + temp.back() + s("\"]");
                                }
                                break;
                        }
-                        case "Exp"_id:
+                        case id<Exp_t>():
                                transformExp(static_cast<Exp_t*>(key), temp, ExpUsage::Closure);
                                temp.back() = s("["sv) + temp.back() + s("]"sv);
                                break;
-                        case "DoubleString"_id:
+                        case id<DoubleString_t>():
                                transformDoubleString(static_cast<DoubleString_t*>(key), temp);
                                temp.back() = s("["sv) + temp.back() + s("]"sv);
                                break;
-                        case "SingleString"_id: transformSingleString(static_cast<SingleString_t*>(key), temp);
+                        case id<SingleString_t>(): transformSingleString(static_cast<SingleString_t*>(key), temp);
                                temp.back() = s("["sv) + temp.back() + s("]"sv);
                                break;
-                        default: break;
+                        default: assert(false); break;
                }
                auto value = pair->value.get();
                switch (value->getId()) {
-                        case "Exp"_id: transformExp(static_cast<Exp_t*>(value), temp, ExpUsage::Closure); break;
+                        case id<Exp_t>(): transformExp(static_cast<Exp_t*>(value), temp, ExpUsage::Closure); break;
-                        case "TableBlock"_id: transformTableBlock(static_cast<TableBlock_t*>(value), temp); break;
+                        case id<TableBlock_t>(): transformTableBlock(static_cast<TableBlock_t*>(value), temp); break;
-                        default: break;
+                        default: assert(false); break;
                }
                out.push_back(temp.front() + s(" = "sv) + temp.back());
        }
@@ -3188,9 +3192,9 @@ private:
        void transformKeyName(KeyName_t* keyName, str_list& out) {
                auto name = keyName->name.get();
                switch (name->getId()) {
-                        case "SelfName"_id: transformSelfName(static_cast<SelfName_t*>(name), out); break;
+                        case id<SelfName_t>(): transformSelfName(static_cast<SelfName_t*>(name), out); break;
-                        case "Name"_id: out.push_back(_parser.toString(name)); break;
+                        case id<Name_t>(): out.push_back(_parser.toString(name)); break;
-                        default: break;
+                        default: assert(false); break;
                }
        }
@@ -3214,18 +3218,18 @@ private:
                        auto seg = static_cast<double_string_content_t*>(_seg);
                        auto content = seg->content.get();
                        switch (content->getId()) {
-                                case "double_string_inner"_id: {
+                                case id<double_string_inner_t>(): {
                                        auto str = _parser.toString(content);
                                        Utils::replace(str, "\r"sv, "");
                                        Utils::replace(str, "\n"sv, "\\n"sv);
                                        temp.push_back(s("\""sv) + str + s("\""sv));
                                        break;
                                }
-                                case "Exp"_id:
+                                case id<Exp_t>():
                                        transformExp(static_cast<Exp_t*>(content), temp, ExpUsage::Closure);
                                        temp.back() = s("tostring("sv) + temp.back() + s(")"sv);
                                        break;
-                                default: break;
+                                default: assert(false); break;
                        }
                }
                out.push_back(temp.empty() ? s("\"\""sv) : join(temp, " .. "sv));
@@ -3234,10 +3238,10 @@ private:
        void transformString(String_t* string, str_list& out) {
                auto str = string->str.get();
                switch (str->getId()) {
-                        case "SingleString"_id: transformSingleString(static_cast<SingleString_t*>(str), out); break;
+                        case id<SingleString_t>(): transformSingleString(static_cast<SingleString_t*>(str), out); break;
-                        case "DoubleString"_id: transformDoubleString(static_cast<DoubleString_t*>(str), out); break;
+                        case id<DoubleString_t>(): transformDoubleString(static_cast<DoubleString_t*>(str), out); break;
-                        case "LuaString"_id: transformLuaString(static_cast<LuaString_t*>(str), out); break;
+                        case id<LuaString_t>(): transformLuaString(static_cast<LuaString_t*>(str), out); break;
-                        default: break;
+                        default: assert(false); break;
                }
        }
@@ -3370,7 +3374,7 @@ private:
                        std::list<ClassMember> members;
                        for (auto content : classDecl->body->contents.objects()) {
                                switch (content->getId()) {
-                                        case "class_member_list"_id: {
+                                        case id<class_member_list_t>(): {
                                                size_t inc = transform_class_member_list(static_cast<class_member_list_t*>(content), members, classVar);
                                                auto it = members.end();
                                                for (size_t i = 0; i < inc; ++i, --it);
@@ -3384,10 +3388,10 @@ private:
                                                }
                                                break;
                                        }
-                                        case "Statement"_id:
+                                        case id<Statement_t>():
                                                transformStatement(static_cast<Statement_t*>(content), statements);
                                                break;
-                                        default: break;
+                                        default: assert(false); break;
                                }
                        }
                        for (auto& member : members) {
@@ -3530,7 +3534,7 @@ private:
                                }
                        }
                        normal_pair->value->traverse([&](ast_node* node) {
-                                if (node->getId() == "ClassDecl"_id) return traversal::Return;
+                                if (node->getId() == id<ClassDecl_t>()) return traversal::Return;
                                if (auto chainValue = ast_cast<ChainValue_t>(node)) {
                                        if (auto callable = ast_cast<Callable_t>(chainValue->items.front())) {
                                                auto var = callable->item.get();
@@ -3538,12 +3542,12 @@ private:
                                                        auto insertSelfToArguments = [&](ast_node* item) {
                                                                auto x = item;
                                                                switch (item->getId()) {
-                                                                        case "InvokeArgs"_id: {
+                                                                        case id<InvokeArgs_t>(): {
                                                                                auto invoke = static_cast<InvokeArgs_t*>(item);
                                                                                invoke->args.push_front(toAst<Exp_t>("self"sv, x));
                                                                                return true;
                                                                        }
-                                                                        case "Invoke"_id: {
+                                                                        case id<Invoke_t>(): {
                                                                                auto invoke = static_cast<Invoke_t*>(item);
                                                                                invoke->args.push_front(toAst<Exp_t>("self"sv, x));
                                                                                return true;
@@ -3584,12 +3588,13 @@ private:
                                decIndentOffset();
                        }
                        switch (keyValue->getId()) {
-                                case "variable_pair"_id:
+                                case id<variable_pair_t>():
                                        transform_variable_pair(static_cast<variable_pair_t*>(keyValue), temp);
                                        break;
-                                case "normal_pair"_id:
+                                case id<normal_pair_t>():
                                        transform_normal_pair(static_cast<normal_pair_t*>(keyValue), temp);
                                        break;
+                                default: assert(false); break;
                        }
                        if (type == MemType::Property) {
                                incIndentOffset();
@@ -3605,10 +3610,10 @@ private:
        void transformAssignable(Assignable_t* assignable, str_list& out) {
                auto item = assignable->item.get();
                switch (item->getId()) {
-                        case "AssignableChain"_id: transformAssignableChain(static_cast<AssignableChain_t*>(item), out); break;
+                        case id<AssignableChain_t>(): transformAssignableChain(static_cast<AssignableChain_t*>(item), out); break;
-                        case "Variable"_id: transformVariable(static_cast<Variable_t*>(item), out); break;
+                        case id<Variable_t>(): transformVariable(static_cast<Variable_t*>(item), out); break;
-                        case "SelfName"_id: transformSelfName(static_cast<SelfName_t*>(item), out); break;
+                        case id<SelfName_t>(): transformSelfName(static_cast<SelfName_t*>(item), out); break;
-                        default: break;
+                        default: assert(false); break;
                }
        }
@@ -3771,23 +3776,23 @@ private:
                auto x = exportNode;
                auto item = exportNode->item.get();
                switch (item->getId()) {
-                        case "ClassDecl"_id: {
+                        case id<ClassDecl_t>(): {
                                auto classDecl = static_cast<ClassDecl_t*>(item);
-                                if (classDecl->name && classDecl->name->item->getId() == "Variable"_id) {
+                                if (classDecl->name && classDecl->name->item->getId() == id<Variable_t>()) {
                                        markVarExported(ExportMode::Any, true);
                                        addExportedVar(_parser.toString(classDecl->name->item));
                                }
                                transformClassDecl(classDecl, out, ExpUsage::Common);
                                break;
                        }
-                        case "export_op"_id:
+                        case id<export_op_t>():
                                if (_parser.toString(item) == "*"sv) {
                                        markVarExported(ExportMode::Any, false);
                                } else {
                                        markVarExported(ExportMode::Capital, false);
                                }
                                break;
-                        case "export_values"_id: {
+                        case id<export_values_t>(): {
                                markVarExported(ExportMode::Any, true);
                                auto values = exportNode->item.to<export_values_t>();
                                if (values->valueList) {
@@ -3817,8 +3822,7 @@ private:
                                }
                                break;
                        }
-                        default:
+                        default: assert(false); break;
-                                break;
                }
        }
@@ -3831,9 +3835,10 @@ private:
                pushScope();
                for (auto pair : pairs) {
                        switch (pair->getId()) {
-                                case "Exp"_id: transformExp(static_cast<Exp_t*>(pair), temp, ExpUsage::Closure); break;
+                                case id<Exp_t>(): transformExp(static_cast<Exp_t*>(pair), temp, ExpUsage::Closure); break;
-                                case "variable_pair"_id: transform_variable_pair(static_cast<variable_pair_t*>(pair), temp); break;
+                                case id<variable_pair_t>(): transform_variable_pair(static_cast<variable_pair_t*>(pair), temp); break;
-                                case "normal_pair"_id: transform_normal_pair(static_cast<normal_pair_t*>(pair), temp); break;
+                                case id<normal_pair_t>(): transform_normal_pair(static_cast<normal_pair_t*>(pair), temp); break;
+                                default: assert(false); break;
                        }
                        temp.back() = indent() + temp.back() + (pair == pairs.back() ? Empty : s(","sv)) + nll(pair);
                }
@@ -3863,17 +3868,18 @@ private:
                auto compInner = comp->forLoop.get();
                for (auto item : compInner->items.objects()) {
                        switch (item->getId()) {
-                                case "CompForEach"_id:
+                                case id<CompForEach_t>():
                                        transformCompForEach(static_cast<CompForEach_t*>(item), temp);
                                        break;
-                                case "CompFor"_id:
+                                case id<CompFor_t>():
                                        transformCompFor(static_cast<CompFor_t*>(item), temp);
                                        break;
-                                case "Exp"_id:
+                                case id<Exp_t>():
                                        transformExp(static_cast<Exp_t*>(item), temp, ExpUsage::Closure);
                                        temp.back() = indent() + s("if "sv) + temp.back() + s(" then"sv) + nll(item);
                                        pushScope();
                                        break;
+                                default: assert(false); break;
                        }
                }
                transformExp(comp->key, kv, ExpUsage::Closure);
@@ -3989,7 +3995,7 @@ private:
                auto assign = x->new_ptr<Assign_t>();
                for (auto name : import->names.objects()) {
                        switch (name->getId()) {
-                                case "Variable"_id: {
+                                case id<Variable_t>(): {
                                        auto var = ast_to<Variable_t>(name);
                                        {
                                                auto callable = toAst<Callable_t>(objVar, x);
@@ -4015,7 +4021,7 @@ private:
                                        expList->exprs.push_back(exp);
                                        break;
                                }
-                                case "colon_import_name"_id: {
+                                case id<colon_import_name_t>(): {
                                        auto var = static_cast<colon_import_name_t*>(name)->name.get();
                                        {
                                                auto nameNode = var->name.get();
@@ -4042,6 +4048,7 @@ private:
                                        expList->exprs.push_back(exp);
                                        break;
                                }
+                                default: assert(false); break;
                        }
                }
                if (objAssign) {
@@ -4101,14 +4108,13 @@ private:
        void transformImport(Import_t* import, str_list& out) {
                auto content = import->content.get();
                switch (content->getId()) {
-                        case "ImportAs"_id:
+                        case id<ImportAs_t>():
                                transformImportAs(static_cast<ImportAs_t*>(content), out);
                                break;
-                        case "ImportFrom"_id:
+                        case id<ImportFrom_t>():
                                transformImportFrom(static_cast<ImportFrom_t*>(content), out);
                                break;
-                        default:
+                        default: assert(false); break;
-                                break;
                }
        }
diff --git a/src/MoonP/parser.hpp b/src/MoonP/parser.hpp
index 01d1050..14abe1a 100644
--- a/src/MoonP/parser.hpp
+++ b/src/MoonP/parser.hpp
@@ -28,17 +28,6 @@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 namespace parserlib {
-// const str hash helper functions
-inline constexpr size_t hash(char const* input) {
-        return *input ? *input + 33ull * hash(input + 1) : 5381;
-}
-inline size_t hash(const char* input, int size, int index) {
-        return index < size ? input[index] + 33ull * hash(input, size, index + 1) : 5381;
-}
-inline size_t constexpr operator"" _id(const char* s, size_t) {
-        return hash(s);
-}
 ///type of the parser's input.
 typedef std::basic_string<wchar_t> input;
 typedef input::iterator input_it;
diff --git a/src/moonp.cpp b/src/moonp.cpp
index cb53b55..32d85ed 100644
--- a/src/moonp.cpp
+++ b/src/moonp.cpp
@@ -37,43 +37,37 @@ int main(int narg, const char** args) {
        std::string resultFile;
        std::list<std::string> files;
        for (int i = 1; i < narg; ++i) {
-                switch (hash(args[i])) {
+                std::string arg = args[i];
-                        case "-l"_id:
+                if (arg == "-l"sv) {
-                                config.reserveLineNumber = true;
+                        config.reserveLineNumber = true;
-                                break;
+                } else if (arg == "-p"sv) {
-                        case "-p"_id:
+                        writeToFile = false;
-                                writeToFile = false;
+                } else if (arg == "-t"sv) {
-                                break;
+                        ++i;
-                        case "-t"_id:
+                        if (i < narg) {
-                                ++i;
+                                targetPath = args[i];
-                                if (i < narg) {
+                        } else {
-                                        targetPath = args[i];
-                                } else {
-                                        std::cout << help;
-                                        return 1;
-                                }
-                                break;
-                        case "-b"_id:
-                                dumpCompileTime = true;
-                                break;
-                        case "-h"_id:
                                std::cout << help;
-                                return 0;
+                                return 1;
-                        case "-v"_id:
+                        }
-                                std::cout << "Moonscript version: " << MoonP::moonScriptVersion() << '\n';
+                } else if (arg == "-b"sv) {
-                                return 0;
+                        dumpCompileTime = true;
-                        case "-o"_id:
+                } else if (arg == "-h"sv) {
-                                ++i;
+                        std::cout << help;
-                                if (i < narg) {
+                        return 0;
-                                        resultFile = args[i];
+                } else if (arg == "-v"sv) {
-                                } else {
+                        std::cout << "Moonscript version: " << MoonP::moonScriptVersion() << '\n';
-                                        std::cout << help;
+                        return 0;
-                                        return 1;
+                } else if (arg == "-o"sv) {
-                                }
+                        ++i;
-                                break;
+                        if (i < narg) {
-                        default:
+                                resultFile = args[i];
-                                files.push_back(args[i]);
+                        } else {
-                                break;
+                                std::cout << help;
+                                return 1;
+                        }
+                } else {
+                        files.push_back(arg);
                }
        }
        if (files.empty()) {