diff --git a/aot/main.cpp b/aot/main.cpp
index 8dbd680977fa6e901ca1e41d7f6dbc8235458125..a647f00b6c5164bc50136adad2e072dd19077f69 100644
--- a/aot/main.cpp
+++ b/aot/main.cpp
@@ -130,7 +130,7 @@ int Run(int argc, const char **argv)
         return err.ErrorCode();
     }
 
-    GenerateProgram(program, options->CompilerOutput(), options->OptLevel(), options->CompilerOptions().dumpAsm,
+    GenerateProgram(program, options->CompilerOutput(), options->OptLevel(), options->CompilerOptions().dump_asm_,
                     options->SizeStat());
     delete program;
 
diff --git a/aot/options.cpp b/aot/options.cpp
index 9be3f001c5b1f2f8a6c5e7e5cd796649fe38f70d..72b0a67863d579d1ff29b9004f4c9526a7be59af 100644
--- a/aot/options.cpp
+++ b/aot/options.cpp
@@ -96,29 +96,29 @@ bool Options::Parse(int argc, const char **argv)
         ss << "optional arguments:" << std::endl;
         ss << argparser_->GetHelpString() << std::endl;
 
-        errorMsg_ = ss.str();
+        error_msg_ = ss.str();
         return false;
     }
 
-    sourceFile_ = inputFile.GetValue();
-    std::ifstream inputStream(sourceFile_.c_str());
+    source_file_ = inputFile.GetValue();
+    std::ifstream inputStream(source_file_.c_str());
 
     if (inputStream.fail()) {
-        errorMsg_ = "Failed to open file: ";
-        errorMsg_.append(sourceFile_);
+        error_msg_ = "Failed to open file: ";
+        error_msg_.append(source_file_);
         return false;
     }
 
     std::stringstream ss;
     ss << inputStream.rdbuf();
-    parserInput_ = ss.str();
+    parser_input_ = ss.str();
 
-    sourceFile_ = BaseName(sourceFile_);
+    source_file_ = BaseName(source_file_);
 
     if (!outputFile.GetValue().empty()) {
-        compilerOutput_ = outputFile.GetValue();
+        compiler_output_ = outputFile.GetValue();
     } else {
-        compilerOutput_ = RemoveExtension(sourceFile_).append(".abc");
+        compiler_output_ = RemoveExtension(source_file_).append(".abc");
     }
 
     std::string extension = inputExtension.GetValue();
@@ -131,13 +131,13 @@ bool Options::Parse(int argc, const char **argv)
         } else if (extension == "as") {
             extension_ = es2panda::ScriptExtension::AS;
         } else {
-            errorMsg_ = "Invalid extension (available options: js, ts, as)";
+            error_msg_ = "Invalid extension (available options: js, ts, as)";
             return false;
         }
     }
 
-    optLevel_ = opOptLevel.GetValue();
-    threadCount_ = opThreadCount.GetValue();
+    opt_level_ = opOptLevel.GetValue();
+    thread_count_ = opThreadCount.GetValue();
 
     if (opParseOnly.GetValue()) {
         options_ |= OptionFlags::PARSE_ONLY;
@@ -151,11 +151,11 @@ bool Options::Parse(int argc, const char **argv)
         options_ |= OptionFlags::SIZE_STAT;
     }
 
-    compilerOptions_.dumpAsm = opDumpAssembly.GetValue();
-    compilerOptions_.dumpAst = opDumpAst.GetValue();
-    compilerOptions_.dumpDebugInfo = opDumpDebugInfo.GetValue();
-    compilerOptions_.isDebug = opDebugInfo.GetValue();
-    compilerOptions_.parseOnly = opParseOnly.GetValue();
+    compiler_options_.dump_asm_ = opDumpAssembly.GetValue();
+    compiler_options_.dump_ast_ = opDumpAst.GetValue();
+    compiler_options_.dump_debug_info_ = opDumpDebugInfo.GetValue();
+    compiler_options_.is_debug_ = opDebugInfo.GetValue();
+    compiler_options_.parse_only_ = opParseOnly.GetValue();
 
     return true;
 }
diff --git a/aot/options.h b/aot/options.h
index af8c8e3093a40394bd8679a28407a28d4dd16708..484c4b9ecce37446a26eb8c21f200d7457670480 100644
--- a/aot/options.h
+++ b/aot/options.h
@@ -67,37 +67,37 @@ public:
 
     const es2panda::CompilerOptions &CompilerOptions() const
     {
-        return compilerOptions_;
+        return compiler_options_;
     }
 
     const std::string &ParserInput() const
     {
-        return parserInput_;
+        return parser_input_;
     }
 
     const std::string &CompilerOutput() const
     {
-        return compilerOutput_;
+        return compiler_output_;
     }
 
     const std::string &SourceFile() const
     {
-        return sourceFile_;
+        return source_file_;
     }
 
     const std::string &ErrorMsg() const
     {
-        return errorMsg_;
+        return error_msg_;
     }
 
     int OptLevel() const
     {
-        return optLevel_;
+        return opt_level_;
     }
 
     int ThreadCount() const
     {
-        return threadCount_;
+        return thread_count_;
     }
 
     bool ParseModule() const
@@ -117,16 +117,16 @@ public:
 
 private:
     es2panda::ScriptExtension extension_ {es2panda::ScriptExtension::JS};
-    es2panda::CompilerOptions compilerOptions_ {};
+    es2panda::CompilerOptions compiler_options_ {};
     OptionFlags options_ {OptionFlags::DEFAULT};
     panda::PandArgParser *argparser_;
-    std::string parserInput_;
-    std::string compilerOutput_;
+    std::string parser_input_;
+    std::string compiler_output_;
     std::string result_;
-    std::string sourceFile_;
-    std::string errorMsg_;
-    int optLevel_ {0};
-    int threadCount_ {0};
+    std::string source_file_;
+    std::string error_msg_;
+    int opt_level_ {0};
+    int thread_count_ {0};
 };
 
 }  // namespace panda::es2panda::aot
diff --git a/binder/binder.cpp b/binder/binder.cpp
index d2a8b2ad397c8be9b3a5a17ca306bd6354d2d199..9ffe0fa018a41c0b2bbb33f0680b80907ff9f41e 100644
--- a/binder/binder.cpp
+++ b/binder/binder.cpp
@@ -45,12 +45,12 @@ namespace panda::es2panda::binder {
 void Binder::InitTopScope()
 {
     if (program_->Kind() == parser::ScriptKind::MODULE) {
-        topScope_ = Allocator()->New<ModuleScope>(Allocator());
+        top_scope_ = Allocator()->New<ModuleScope>(Allocator());
     } else {
-        topScope_ = Allocator()->New<GlobalScope>(Allocator());
+        top_scope_ = Allocator()->New<GlobalScope>(Allocator());
     }
 
-    scope_ = topScope_;
+    scope_ = top_scope_;
 }
 
 ParameterDecl *Binder::AddParamDecl(const ir::AstNode *param)
@@ -72,15 +72,15 @@ void Binder::ThrowRedeclaration(const lexer::SourcePosition &pos, const util::St
 
     std::stringstream ss;
     ss << "Variable '" << name << "' has already been declared.";
-    throw Error(ErrorType::SYNTAX, ss.str(), loc.line, loc.col);
+    throw Error(ErrorType::SYNTAX, ss.str(), loc.line_, loc.col_);
 }
 
 void Binder::IdentifierAnalysis()
 {
     ASSERT(program_->Ast());
-    ASSERT(scope_ == topScope_);
+    ASSERT(scope_ == top_scope_);
 
-    BuildFunction(topScope_, "main");
+    BuildFunction(top_scope_, "main");
     ResolveReferences(program_->Ast());
     AddMandatoryParams();
 }
@@ -88,12 +88,12 @@ void Binder::IdentifierAnalysis()
 void Binder::LookupReference(const util::StringView &name)
 {
     ScopeFindResult res = scope_->Find(name);
-    if (res.level == 0) {
+    if (res.level_ == 0) {
         return;
     }
 
-    ASSERT(res.variable);
-    res.variable->SetLexical(res.scope);
+    ASSERT(res.variable_);
+    res.variable_->SetLexical(res.scope_);
 }
 
 void Binder::InstantiateArguments()
@@ -142,26 +142,26 @@ void Binder::LookupIdentReference(ir::Identifier *ident)
     }
 
     ScopeFindResult res = scope_->Find(ident->Name());
-    if (res.level != 0) {
-        ASSERT(res.variable);
-        res.variable->SetLexical(res.scope);
+    if (res.level_ != 0) {
+        ASSERT(res.variable_);
+        res.variable_->SetLexical(res.scope_);
     }
 
-    if (!res.variable) {
+    if (!res.variable_) {
         return;
     }
 
-    if (res.variable->Declaration()->IsLetOrConstDecl() && !res.variable->HasFlag(VariableFlags::INITIALIZED)) {
+    if (res.variable_->Declaration()->IsLetOrConstDecl() && !res.variable_->HasFlag(VariableFlags::INITIALIZED)) {
         ident->SetTdz();
     }
 
-    ident->SetVariable(res.variable);
+    ident->SetVariable(res.variable_);
 }
 
 void Binder::BuildFunction(FunctionScope *funcScope, util::StringView name)
 {
-    uint32_t idx = functionScopes_.size();
-    functionScopes_.push_back(funcScope);
+    uint32_t idx = function_scopes_.size();
+    function_scopes_.push_back(funcScope);
 
     std::stringstream ss;
     ss << "func_" << name << "_" << std::to_string(idx);
@@ -245,8 +245,8 @@ void Binder::BuildClassDefinition(ir::ClassDefinition *classDef)
     if (classDef->Parent()->IsClassDeclaration()) {
         ScopeFindResult res = scope_->Find(classDef->Ident()->Name());
 
-        ASSERT(res.variable && res.variable->Declaration()->IsLetDecl());
-        res.variable->AddFlag(VariableFlags::INITIALIZED);
+        ASSERT(res.variable_ && res.variable_->Declaration()->IsLetDecl());
+        res.variable_->AddFlag(VariableFlags::INITIALIZED);
     }
 
     auto scopeCtx = LexicalScope<LocalScope>::Enter(this, classDef->Scope());
@@ -258,8 +258,8 @@ void Binder::BuildClassDefinition(ir::ClassDefinition *classDef)
     if (classDef->Ident()) {
         ScopeFindResult res = scope_->Find(classDef->Ident()->Name());
 
-        ASSERT(res.variable && res.variable->Declaration()->IsConstDecl());
-        res.variable->AddFlag(VariableFlags::INITIALIZED);
+        ASSERT(res.variable_ && res.variable_->Declaration()->IsConstDecl());
+        res.variable_->AddFlag(VariableFlags::INITIALIZED);
     }
 
     ResolveReference(classDef, classDef->Ctor());
@@ -462,15 +462,15 @@ void Binder::AddMandatoryParams(const MandatoryParams &params)
 
 void Binder::AddMandatoryParams()
 {
-    ASSERT(scope_ == topScope_);
-    ASSERT(!functionScopes_.empty());
-    auto iter = functionScopes_.begin();
+    ASSERT(scope_ == top_scope_);
+    ASSERT(!function_scopes_.empty());
+    auto iter = function_scopes_.begin();
     [[maybe_unused]] auto *funcScope = *iter++;
 
     ASSERT(funcScope->IsGlobalScope() || funcScope->IsModuleScope());
     AddMandatoryParams(FUNCTION_MANDATORY_PARAMS);
 
-    for (; iter != functionScopes_.end(); iter++) {
+    for (; iter != function_scopes_.end(); iter++) {
         funcScope = *iter;
         const auto *scriptFunc = funcScope->Node()->AsScriptFunction();
 
diff --git a/binder/binder.h b/binder/binder.h
index 10d52ef951c5dca86d64509b83724fa55e8b4b6e..f5325e96edd63f4004b899577d1b549969c31416 100644
--- a/binder/binder.h
+++ b/binder/binder.h
@@ -41,7 +41,7 @@ class VariableScope;
 
 class Binder {
 public:
-    explicit Binder(parser::Program *program) : program_(program), functionScopes_(Allocator()->Adapter()) {}
+    explicit Binder(parser::Program *program) : program_(program), function_scopes_(Allocator()->Adapter()) {}
     NO_COPY_SEMANTIC(Binder);
     DEFAULT_MOVE_SEMANTIC(Binder);
     ~Binder() = default;
@@ -64,7 +64,7 @@ public:
 
     GlobalScope *TopScope() const
     {
-        return topScope_;
+        return top_scope_;
     }
 
     [[noreturn]] void ThrowRedeclaration(const lexer::SourcePosition &pos, const util::StringView &name);
@@ -79,12 +79,12 @@ public:
 
     const ArenaVector<FunctionScope *> &Functions() const
     {
-        return functionScopes_;
+        return function_scopes_;
     }
 
     ArenaVector<FunctionScope *> Functions()
     {
-        return functionScopes_;
+        return function_scopes_;
     }
 
     const parser::Program *Program() const
@@ -135,9 +135,9 @@ private:
     void ResolveReferences(const ir::AstNode *parent);
 
     parser::Program *program_ {};
-    GlobalScope *topScope_ {};
+    GlobalScope *top_scope_ {};
     Scope *scope_ {};
-    ArenaVector<FunctionScope *> functionScopes_;
+    ArenaVector<FunctionScope *> function_scopes_;
 };
 
 template <typename T>
@@ -158,7 +158,7 @@ public:
     ~LexicalScope()
     {
         ASSERT(binder_);
-        binder_->scope_ = prevScope_;
+        binder_->scope_ = prev_scope_;
     }
 
     [[nodiscard]] static LexicalScope<T> Enter(Binder *binder, T *scope)
@@ -172,14 +172,14 @@ public:
 private:
     NO_COPY_SEMANTIC(LexicalScope);
 
-    explicit LexicalScope(T *scope, Binder *binder) : binder_(binder), scope_(scope), prevScope_(binder->scope_)
+    explicit LexicalScope(T *scope, Binder *binder) : binder_(binder), scope_(scope), prev_scope_(binder->scope_)
     {
         binder_->scope_ = scope_;
     }
 
     Binder *binder_ {};
     T *scope_ {};
-    Scope *prevScope_ {};
+    Scope *prev_scope_ {};
 };
 
 template <typename T, typename... Args>
diff --git a/binder/declaration.h b/binder/declaration.h
index ab65a7579ac6db9768e837f80d82e57f8cbcdd62..0383e0e40755b0070012cfa4a54d5cf3fae7376e 100644
--- a/binder/declaration.h
+++ b/binder/declaration.h
@@ -113,7 +113,7 @@ private:
 
 class EnumLiteralDecl : public Decl {
 public:
-    explicit EnumLiteralDecl(util::StringView name, bool isConst) : Decl(name), isConst_(isConst) {}
+    explicit EnumLiteralDecl(util::StringView name, bool isConst) : Decl(name), is_const_(isConst) {}
 
     DeclType Type() const override
     {
@@ -122,7 +122,7 @@ public:
 
     bool IsConst() const
     {
-        return isConst_;
+        return is_const_;
     }
 
     void BindScope(LocalScope *scope)
@@ -137,7 +137,7 @@ public:
 
 private:
     LocalScope *scope_ {};
-    bool isConst_ {};
+    bool is_const_ {};
 };
 
 class InterfaceDecl : public MultiDecl<ir::TSInterfaceDeclaration> {
@@ -247,19 +247,19 @@ public:
 class ImportDecl : public Decl {
 public:
     explicit ImportDecl(util::StringView importName, util::StringView localName)
-        : Decl(localName), importName_(importName)
+        : Decl(localName), import_name_(importName)
     {
     }
 
     explicit ImportDecl(util::StringView importName, util::StringView localName, const ir::AstNode *node)
-        : Decl(localName), importName_(importName)
+        : Decl(localName), import_name_(importName)
     {
         BindNode(node);
     }
 
     const util::StringView &ImportName() const
     {
-        return importName_;
+        return import_name_;
     }
 
     const util::StringView &LocalName() const
@@ -273,25 +273,25 @@ public:
     }
 
 private:
-    util::StringView importName_;
+    util::StringView import_name_;
 };
 
 class ExportDecl : public Decl {
 public:
     explicit ExportDecl(util::StringView exportName, util::StringView localName)
-        : Decl(localName), exportName_(exportName)
+        : Decl(localName), export_name_(exportName)
     {
     }
 
     explicit ExportDecl(util::StringView exportName, util::StringView localName, const ir::AstNode *node)
-        : Decl(localName), exportName_(exportName)
+        : Decl(localName), export_name_(exportName)
     {
         BindNode(node);
     }
 
     const util::StringView &ExportName() const
     {
-        return exportName_;
+        return export_name_;
     }
 
     const util::StringView &LocalName() const
@@ -305,7 +305,7 @@ public:
     }
 
 private:
-    util::StringView exportName_;
+    util::StringView export_name_;
 };
 
 }  // namespace panda::es2panda::binder
diff --git a/binder/scope.cpp b/binder/scope.cpp
index 402bdd7a0c77989d8eb0451300936e38afe78d8d..39cf92bea665f72d34c230b5f12d39b12a0aa481 100644
--- a/binder/scope.cpp
+++ b/binder/scope.cpp
@@ -237,8 +237,8 @@ std::tuple<ParameterDecl *, const ir::AstNode *> ParamScope::AddParamDecl(ArenaA
 
 void FunctionParamScope::BindName(ArenaAllocator *allocator, util::StringView name)
 {
-    nameVar_ = AddDecl<ConstDecl, LocalVariable>(allocator, name, VariableFlags::INITIALIZED);
-    functionScope_->Bindings().insert({name, nameVar_});
+    name_var_ = AddDecl<ConstDecl, LocalVariable>(allocator, name, VariableFlags::INITIALIZED);
+    function_scope_->Bindings().insert({name, name_var_});
 }
 
 bool FunctionParamScope::AddBinding([[maybe_unused]] ArenaAllocator *allocator,
@@ -421,7 +421,7 @@ bool ModuleScope::ExportAnalysis()
 
             if (!variable->IsModuleVariable()) {
                 variable->AddFlag(VariableFlags::LOCAL_EXPORT);
-                localExports_.insert({variable, decl->ExportName()});
+                local_exports_.insert({variable, decl->ExportName()});
             }
         }
     }
@@ -448,41 +448,41 @@ void LoopDeclarationScope::ConvertToVariableScope(ArenaAllocator *allocator)
             continue;
         }
 
-        slotIndex_++;
-        loopType_ = ScopeType::LOOP_DECL;
+        slot_index_++;
+        loop_type_ = ScopeType::LOOP_DECL;
         auto *copiedVar = var->AsLocalVariable()->Copy(allocator, var->Declaration());
         copiedVar->AddFlag(VariableFlags::INITIALIZED | VariableFlags::PER_ITERATION);
         var->AddFlag(VariableFlags::LOOP_DECL);
-        loopScope_->Bindings().insert({name, copiedVar});
+        loop_scope_->Bindings().insert({name, copiedVar});
     }
 
-    if (loopType_ == ScopeType::LOOP_DECL) {
-        slotIndex_ = std::max(slotIndex_, parent_->EnclosingVariableScope()->LexicalSlots());
-        initScope_ = allocator->New<LocalScope>(allocator, parent_);
-        initScope_->BindNode(node_);
-        initScope_->Bindings() = bindings_;
+    if (loop_type_ == ScopeType::LOOP_DECL) {
+        slot_index_ = std::max(slot_index_, parent_->EnclosingVariableScope()->LexicalSlots());
+        init_scope_ = allocator->New<LocalScope>(allocator, parent_);
+        init_scope_->BindNode(node_);
+        init_scope_->Bindings() = bindings_;
     }
 }
 
 void LoopScope::ConvertToVariableScope(ArenaAllocator *allocator)
 {
-    declScope_->ConvertToVariableScope(allocator);
+    decl_scope_->ConvertToVariableScope(allocator);
 
-    if (loopType_ != ScopeType::LOCAL) {
+    if (loop_type_ != ScopeType::LOCAL) {
         return;
     }
 
     for (const auto &[_, var] : bindings_) {
         (void)_;
         if (var->LexicalBound() && var->Declaration()->IsLetDecl()) {
-            ASSERT(declScope_->NeedLexEnv());
-            loopType_ = ScopeType::LOOP;
+            ASSERT(decl_scope_->NeedLexEnv());
+            loop_type_ = ScopeType::LOOP;
             break;
         }
     }
 
-    if (loopType_ == ScopeType::LOOP) {
-        slotIndex_ = std::max(slotIndex_, declScope_->LexicalSlots());
+    if (loop_type_ == ScopeType::LOOP) {
+        slot_index_ = std::max(slot_index_, decl_scope_->LexicalSlots());
     }
 }
 
@@ -495,7 +495,7 @@ bool CatchParamScope::AddBinding(ArenaAllocator *allocator, Variable *currentVar
 bool CatchScope::AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
                             [[maybe_unused]] ScriptExtension extension)
 {
-    if (!newDecl->IsVarDecl() && paramScope_->FindLocal(newDecl->Name())) {
+    if (!newDecl->IsVarDecl() && param_scope_->FindLocal(newDecl->Name())) {
         return false;
     }
 
diff --git a/binder/scope.h b/binder/scope.h
index 881abfb48ec6e46b012a7ed05f2cb1b43acdbad8..611a3ca118e7277fbc69fec24541412df6e84430 100644
--- a/binder/scope.h
+++ b/binder/scope.h
@@ -46,17 +46,19 @@ class ScopeFindResult {
 public:
     ScopeFindResult() = default;
     ScopeFindResult(util::StringView n, Scope *s, uint32_t l, Variable *v) : ScopeFindResult(n, s, l, l, v) {}
-    ScopeFindResult(Scope *s, uint32_t l, uint32_t ll, Variable *v) : scope(s), level(l), lexLevel(ll), variable(v) {}
+    ScopeFindResult(Scope *s, uint32_t l, uint32_t ll, Variable *v) : scope_(s), level_(l), lex_level_(ll), variable_(v)
+    {
+    }
     ScopeFindResult(util::StringView n, Scope *s, uint32_t l, uint32_t ll, Variable *v)
-        : name(n), scope(s), level(l), lexLevel(ll), variable(v)
+        : name_(n), scope_(s), level_(l), lex_level_(ll), variable_(v)
     {
     }
 
-    util::StringView name {};
-    Scope *scope {};
-    uint32_t level {};
-    uint32_t lexLevel {};
-    Variable *variable {};
+    util::StringView name_ {};
+    Scope *scope_ {};
+    uint32_t level_ {};
+    uint32_t lex_level_ {};
+    Variable *variable_ {};
 };
 
 class Scope {
@@ -138,22 +140,22 @@ public:
 
     const compiler::IRNode *ScopeStart() const
     {
-        return startIns_;
+        return start_ins_;
     }
 
     const compiler::IRNode *ScopeEnd() const
     {
-        return endIns_;
+        return end_ins_;
     }
 
     void SetScopeStart(const compiler::IRNode *ins)
     {
-        startIns_ = ins;
+        start_ins_ = ins;
     }
 
     void SetScopeEnd(const compiler::IRNode *ins)
     {
-        endIns_ = ins;
+        end_ins_ = ins;
     }
 
     const ir::AstNode *Node() const
@@ -237,8 +239,8 @@ protected:
     ArenaVector<Decl *> decls_;
     VariableMap bindings_;
     const ir::AstNode *node_ {};
-    const compiler::IRNode *startIns_ {};
-    const compiler::IRNode *endIns_ {};
+    const compiler::IRNode *start_ins_ {};
+    const compiler::IRNode *end_ins_ {};
 };
 
 class VariableScope : public Scope {
@@ -264,17 +266,17 @@ public:
 
     uint32_t NextSlot()
     {
-        return slotIndex_++;
+        return slot_index_++;
     }
 
     uint32_t LexicalSlots() const
     {
-        return slotIndex_;
+        return slot_index_;
     }
 
     bool NeedLexEnv() const
     {
-        return slotIndex_ != 0;
+        return slot_index_ != 0;
     }
 
 protected:
@@ -294,7 +296,7 @@ protected:
     bool AddLexical(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl);
 
     VariableScopeFlags flags_ {};
-    uint32_t slotIndex_ {};
+    uint32_t slot_index_ {};
 };
 
 class ParamScope : public Scope {
@@ -335,17 +337,17 @@ public:
 
     FunctionScope *GetFunctionScope() const
     {
-        return functionScope_;
+        return function_scope_;
     }
 
     void BindFunctionScope(FunctionScope *funcScope)
     {
-        functionScope_ = funcScope;
+        function_scope_ = funcScope;
     }
 
     LocalVariable *NameVar() const
     {
-        return nameVar_;
+        return name_var_;
     }
 
     void BindName(ArenaAllocator *allocator, util::StringView name);
@@ -363,8 +365,8 @@ public:
     friend class ScopeWithParamScope;
 
 private:
-    FunctionScope *functionScope_ {};
-    LocalVariable *nameVar_ {};
+    FunctionScope *function_scope_ {};
+    LocalVariable *name_var_ {};
 };
 
 template <typename E, typename T>
@@ -383,21 +385,21 @@ public:
         ASSERT(this->parent_ == paramScope);
         ASSERT(this->bindings_.empty());
 
-        paramScope_ = paramScope;
+        param_scope_ = paramScope;
     }
 
     T *ParamScope()
     {
-        return paramScope_;
+        return param_scope_;
     }
 
     const T *ParamScope() const
     {
-        return paramScope_;
+        return param_scope_;
     }
 
 protected:
-    T *paramScope_;
+    T *param_scope_;
 };
 
 class FunctionScope : public ScopeWithParamScope<VariableScope, FunctionParamScope> {
@@ -412,7 +414,7 @@ public:
     void BindName(util::StringView name, util::StringView internalName)
     {
         name_ = name;
-        internalName_ = internalName;
+        internal_name_ = internalName;
     }
 
     const util::StringView &Name() const
@@ -422,7 +424,7 @@ public:
 
     const util::StringView &InternalName() const
     {
-        return internalName_;
+        return internal_name_;
     }
 
     bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
@@ -430,7 +432,7 @@ public:
 
 private:
     util::StringView name_ {};
-    util::StringView internalName_ {};
+    util::StringView internal_name_ {};
 };
 
 class LocalScope : public Scope {
@@ -482,7 +484,7 @@ public:
 
     ScopeType Type() const override
     {
-        return loopType_;
+        return loop_type_;
     }
 
     bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
@@ -494,7 +496,7 @@ public:
     Scope *InitScope()
     {
         if (NeedLexEnv()) {
-            return initScope_;
+            return init_scope_;
         }
 
         return this;
@@ -504,9 +506,9 @@ public:
 
 private:
     friend class LoopScope;
-    LoopScope *loopScope_ {};
-    LocalScope *initScope_ {};
-    ScopeType loopType_ {ScopeType::LOCAL};
+    LoopScope *loop_scope_ {};
+    LocalScope *init_scope_ {};
+    ScopeType loop_type_ {ScopeType::LOCAL};
 };
 
 class LoopScope : public VariableScope {
@@ -515,18 +517,18 @@ public:
 
     LoopDeclarationScope *DeclScope()
     {
-        return declScope_;
+        return decl_scope_;
     }
 
     void BindDecls(LoopDeclarationScope *declScope)
     {
-        declScope_ = declScope;
-        declScope_->loopScope_ = this;
+        decl_scope_ = declScope;
+        decl_scope_->loop_scope_ = this;
     }
 
     ScopeType Type() const override
     {
-        return loopType_;
+        return loop_type_;
     }
 
     void ConvertToVariableScope(ArenaAllocator *allocator);
@@ -538,8 +540,8 @@ public:
     }
 
 protected:
-    LoopDeclarationScope *declScope_ {};
-    ScopeType loopType_ {ScopeType::LOCAL};
+    LoopDeclarationScope *decl_scope_ {};
+    ScopeType loop_type_ {ScopeType::LOCAL};
 };
 
 class GlobalScope : public FunctionScope {
@@ -547,7 +549,7 @@ public:
     explicit GlobalScope(ArenaAllocator *allocator) : FunctionScope(allocator, nullptr)
     {
         auto *paramScope = allocator->New<FunctionParamScope>(allocator, this);
-        paramScope_ = paramScope;
+        param_scope_ = paramScope;
     }
 
     ScopeType Type() const override
@@ -572,7 +574,7 @@ public:
           allocator_(allocator),
           imports_(allocator_->Adapter()),
           exports_(allocator_->Adapter()),
-          localExports_(allocator_->Adapter())
+          local_exports_(allocator_->Adapter())
     {
     }
 
@@ -593,7 +595,7 @@ public:
 
     const LocalExportNameMap &LocalExports() const
     {
-        return localExports_;
+        return local_exports_;
     }
 
     void AddImportDecl(const ir::ImportDeclaration *importDecl, ImportDeclList &&decls);
@@ -613,7 +615,7 @@ private:
     ArenaAllocator *allocator_;
     ModuleEntry<const ir::ImportDeclaration *, ImportDeclList> imports_;
     ModuleEntry<const ir::AstNode *, ExportDeclList> exports_;
-    LocalExportNameMap localExports_;
+    LocalExportNameMap local_exports_;
 };
 
 template <typename T>
diff --git a/binder/variable.h b/binder/variable.h
index 4302048a8bf2ccafe9887e3574da5bfd7be16f1c..d65a5d6b938110475de79dfabd39257d2736f926 100644
--- a/binder/variable.h
+++ b/binder/variable.h
@@ -76,12 +76,12 @@ public:
 
     checker::Type *TsType() const
     {
-        return tsType_;
+        return ts_type_;
     }
 
     void SetTsType(checker::Type *tsType)
     {
-        tsType_ = tsType;
+        ts_type_ = tsType;
     }
 
     void AddFlag(VariableFlags flag)
@@ -118,7 +118,7 @@ protected:
 
     Decl *decl_;
     VariableFlags flags_ {};
-    checker::Type *tsType_ {};
+    checker::Type *ts_type_ {};
 };
 
 class LocalVariable : public Variable {
@@ -184,35 +184,35 @@ public:
 
     compiler::VReg &ModuleReg()
     {
-        return moduleReg_;
+        return module_reg_;
     }
 
     compiler::VReg ModuleReg() const
     {
-        return moduleReg_;
+        return module_reg_;
     }
 
     const util::StringView &ExoticName() const
     {
-        return exoticName_;
+        return exotic_name_;
     }
 
     util::StringView &ExoticName()
     {
-        return exoticName_;
+        return exotic_name_;
     }
 
     void SetLexical([[maybe_unused]] Scope *scope) override;
 
 private:
-    compiler::VReg moduleReg_ {};
-    util::StringView exoticName_ {};
+    compiler::VReg module_reg_ {};
+    util::StringView exotic_name_ {};
 };
 
 class EnumVariable : public Variable {
 public:
     explicit EnumVariable(Decl *decl, bool backReference = false)
-        : Variable(decl, VariableFlags::NONE), backReference_(backReference)
+        : Variable(decl, VariableFlags::NONE), back_reference_(backReference)
     {
     }
 
@@ -233,12 +233,12 @@ public:
 
     bool BackReference() const
     {
-        return backReference_;
+        return back_reference_;
     }
 
     void SetBackReference()
     {
-        backReference_ = true;
+        back_reference_ = true;
     }
 
     void ResetDecl(Decl *decl);
@@ -247,7 +247,7 @@ public:
 
 private:
     EnumMemberResult value_ {false};
-    bool backReference_ {};
+    bool back_reference_ {};
 };
 
 }  // namespace panda::es2panda::binder
diff --git a/compiler/base/catchTable.h b/compiler/base/catchTable.h
index 9954ae9ff79d2901a4fb61cd0ce0848c5e67dca7..faf7f47b94a226df2b5452b6fdfe8305b649bd90 100644
--- a/compiler/base/catchTable.h
+++ b/compiler/base/catchTable.h
@@ -68,7 +68,7 @@ private:
 
 class CatchTable {
 public:
-    CatchTable(PandaGen *pg, uint32_t depth) : labelSet_(pg), depth_(depth) {}
+    CatchTable(PandaGen *pg, uint32_t depth) : label_set_(pg), depth_(depth) {}
 
     ~CatchTable() = default;
     NO_COPY_SEMANTIC(CatchTable);
@@ -76,7 +76,7 @@ public:
 
     const TryLabelSet &LabelSet() const
     {
-        return labelSet_;
+        return label_set_;
     }
 
     uint32_t Depth() const
@@ -85,7 +85,7 @@ public:
     }
 
 private:
-    TryLabelSet labelSet_;
+    TryLabelSet label_set_;
     uint32_t depth_;
 };
 
diff --git a/compiler/base/iterators.cpp b/compiler/base/iterators.cpp
index 1bf7ad888797b1fb5f2c829aab527b4979a09c8a..8224c2f3975fa6085aa241bee16c31f85dc18ceb 100644
--- a/compiler/base/iterators.cpp
+++ b/compiler/base/iterators.cpp
@@ -24,7 +24,12 @@ namespace panda::es2panda::compiler {
 // Iterator
 
 Iterator::Iterator(PandaGen *pg, const ir::AstNode *node, IteratorType type)
-    : pg_(pg), node_(node), method_(pg->AllocReg()), iterator_(pg->AllocReg()), nextResult_(pg->AllocReg()), type_(type)
+    : pg_(pg),
+      node_(node),
+      method_(pg->AllocReg()),
+      iterator_(pg->AllocReg()),
+      next_result_(pg->AllocReg()),
+      type_(type)
 {
     if (type_ == IteratorType::ASYNC) {
         pg_->GetAsyncIterator(node);
@@ -64,18 +69,18 @@ void Iterator::Next() const
     }
 
     pg_->ThrowIfNotObject(node_);
-    pg_->StoreAccumulator(node_, nextResult_);
+    pg_->StoreAccumulator(node_, next_result_);
 }
 
 void Iterator::Complete() const
 {
-    pg_->LoadObjByName(node_, nextResult_, "done");
+    pg_->LoadObjByName(node_, next_result_, "done");
     pg_->ToBoolean(node_);
 }
 
 void Iterator::Value() const
 {
-    pg_->LoadObjByName(node_, nextResult_, "value");
+    pg_->LoadObjByName(node_, next_result_, "value");
 }
 
 void Iterator::Close(bool abruptCompletion) const
diff --git a/compiler/base/iterators.h b/compiler/base/iterators.h
index 0f23818d9ed2015bc8db01e274ba63b5a064dea1..ed1db0aef131b8132bfac30551c27b95020a8784 100644
--- a/compiler/base/iterators.h
+++ b/compiler/base/iterators.h
@@ -47,7 +47,7 @@ public:
 
     VReg NextResult() const
     {
-        return nextResult_;
+        return next_result_;
     }
 
     const ir::AstNode *Node() const
@@ -70,7 +70,7 @@ protected:
     // These 3 regs must be allocated continously
     VReg method_;
     VReg iterator_;
-    VReg nextResult_;
+    VReg next_result_;
     IteratorType type_;
 };
 
diff --git a/compiler/base/lexenv.cpp b/compiler/base/lexenv.cpp
index f3410f06c2ff81e8e0a5a098f5909111720f2970..21470e7a4b705812a0a26b2b5e4c8907f1feec2d 100644
--- a/compiler/base/lexenv.cpp
+++ b/compiler/base/lexenv.cpp
@@ -43,13 +43,13 @@ static void CheckConstAssignment(PandaGen *pg, const ir::AstNode *node, binder::
 
 static void ExpandLoadLexVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result)
 {
-    pg->LoadLexicalVar(node, result.lexLevel, result.variable->AsLocalVariable()->LexIdx());
-    pg->ThrowUndefinedIfHole(node, result.variable->Name());
+    pg->LoadLexicalVar(node, result.lex_level_, result.variable_->AsLocalVariable()->LexIdx());
+    pg->ThrowUndefinedIfHole(node, result.variable_->Name());
 }
 
 static void ExpandLoadNormalVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result)
 {
-    auto *local = result.variable->AsLocalVariable();
+    auto *local = result.variable_->AsLocalVariable();
 
     if (CheckTdz(node)) {
         pg->LoadConst(node, Constant::JS_HOLE);
@@ -61,7 +61,7 @@ static void ExpandLoadNormalVar(PandaGen *pg, const ir::AstNode *node, const bin
 
 void VirtualLoadVar::Expand(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result)
 {
-    if (result.variable->LexicalBound()) {
+    if (result.variable_->LexicalBound()) {
         ExpandLoadLexVar(pg, node, result);
     } else {
         ExpandLoadNormalVar(pg, node, result);
@@ -87,9 +87,9 @@ static void StoreLocalExport(PandaGen *pg, const ir::AstNode *node, binder::Vari
 
 static void ExpandStoreLexVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDecl)
 {
-    binder::LocalVariable *local = result.variable->AsLocalVariable();
+    binder::LocalVariable *local = result.variable_->AsLocalVariable();
 
-    const auto *decl = result.variable->Declaration();
+    const auto *decl = result.variable_->Declaration();
 
     if (decl->IsLetOrConstDecl() && !isDecl) {
         RegScope rs(pg);
@@ -106,7 +106,7 @@ static void ExpandStoreLexVar(PandaGen *pg, const ir::AstNode *node, const binde
         pg->LoadAccumulator(node, valueReg);
     }
 
-    pg->StoreLexicalVar(node, result.lexLevel, local->LexIdx());
+    pg->StoreLexicalVar(node, result.lex_level_, local->LexIdx());
 
     StoreLocalExport(pg, node, local);
 }
@@ -114,7 +114,7 @@ static void ExpandStoreLexVar(PandaGen *pg, const ir::AstNode *node, const binde
 static void ExpandStoreNormalVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result,
                                  bool isDecl)
 {
-    auto *local = result.variable->AsLocalVariable();
+    auto *local = result.variable_->AsLocalVariable();
     VReg localReg = local->Vreg();
 
     if (!isDecl) {
@@ -132,7 +132,7 @@ static void ExpandStoreNormalVar(PandaGen *pg, const ir::AstNode *node, const bi
 
 void VirtualStoreVar::Expand(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDecl)
 {
-    if (result.variable->LexicalBound()) {
+    if (result.variable_->LexicalBound()) {
         ExpandStoreLexVar(pg, node, result, isDecl);
     } else {
         ExpandStoreNormalVar(pg, node, result, isDecl);
diff --git a/compiler/base/lreference.cpp b/compiler/base/lreference.cpp
index 6fd21e14eedd2b4be322b5746b6411bd6f70a279..0920305bbf4fb3bfd0a29440c30971d6e0213ca0 100644
--- a/compiler/base/lreference.cpp
+++ b/compiler/base/lreference.cpp
@@ -31,7 +31,7 @@ namespace panda::es2panda::compiler {
 
 LReference::LReference(const ir::AstNode *node, PandaGen *pg, bool isDeclaration, ReferenceKind refKind,
                        binder::ScopeFindResult res)
-    : node_(node), pg_(pg), refKind_(refKind), res_(res), isDeclaration_(isDeclaration)
+    : node_(node), pg_(pg), ref_kind_(refKind), res_(res), is_declaration_(isDeclaration)
 {
     if (refKind == ReferenceKind::MEMBER) {
         obj_ = pg_->AllocReg();
@@ -43,7 +43,7 @@ LReference::LReference(const ir::AstNode *node, PandaGen *pg, bool isDeclaration
 
 void LReference::GetValue()
 {
-    switch (refKind_) {
+    switch (ref_kind_) {
         case ReferenceKind::VAR_OR_GLOBAL: {
             pg_->LoadVar(node_->AsIdentifier(), res_);
             break;
@@ -60,9 +60,9 @@ void LReference::GetValue()
 
 void LReference::SetValue()
 {
-    switch (refKind_) {
+    switch (ref_kind_) {
         case ReferenceKind::VAR_OR_GLOBAL: {
-            pg_->StoreVar(node_, res_, isDeclaration_);
+            pg_->StoreVar(node_, res_, is_declaration_);
             break;
         }
         case ReferenceKind::MEMBER: {
@@ -86,12 +86,12 @@ void LReference::SetValue()
 
 ReferenceKind LReference::Kind() const
 {
-    return refKind_;
+    return ref_kind_;
 }
 
 binder::Variable *LReference::Variable() const
 {
-    return res_.variable;
+    return res_.variable_;
 }
 
 LReference LReference::CreateLRef(PandaGen *pg, const ir::AstNode *node, bool isDeclaration)
diff --git a/compiler/base/lreference.h b/compiler/base/lreference.h
index e7edf06f7b90d4f08a94bce2f7faaa85dea5c880..5da628d4079c4d68a886bc16fe1c7b898c4a51d1 100644
--- a/compiler/base/lreference.h
+++ b/compiler/base/lreference.h
@@ -56,11 +56,11 @@ public:
 private:
     const ir::AstNode *node_;
     PandaGen *pg_;
-    ReferenceKind refKind_;
+    ReferenceKind ref_kind_;
     binder::ScopeFindResult res_;
     VReg obj_;
     Operand prop_;
-    bool isDeclaration_;
+    bool is_declaration_;
 };
 
 }  // namespace panda::es2panda::compiler
diff --git a/compiler/core/compileQueue.cpp b/compiler/core/compileQueue.cpp
index 29460a7b3b4a59143e2c994747b7587c334251af..edea06bc46c83e69f05652f4a6679c814e2620e3 100644
--- a/compiler/core/compileQueue.cpp
+++ b/compiler/core/compileQueue.cpp
@@ -76,7 +76,7 @@ CompileQueue::~CompileQueue()
     std::unique_lock<std::mutex> lock(m_);
     terminate_ = true;
     lock.unlock();
-    jobsAvailable_.notify_all();
+    jobs_available_.notify_all();
 
     for (const auto handle_id : threads_) {
         os::thread::ThreadJoin(handle_id, &retval);
@@ -85,24 +85,24 @@ CompileQueue::~CompileQueue()
 
 void CompileQueue::Schedule(CompilerContext *context)
 {
-    ASSERT(jobsCount_ == 0);
+    ASSERT(jobs_count_ == 0);
     std::unique_lock<std::mutex> lock(m_);
     const auto &functions = context->Binder()->Functions();
     jobs_ = new CompileJob[functions.size()]();
 
     for (auto *function : functions) {
-        jobs_[jobsCount_++].SetConext(context, function);
+        jobs_[jobs_count_++].SetConext(context, function);
     }
 
     lock.unlock();
-    jobsAvailable_.notify_all();
+    jobs_available_.notify_all();
 }
 
 void CompileQueue::Worker(CompileQueue *queue)
 {
     while (true) {
         std::unique_lock<std::mutex> lock(queue->m_);
-        queue->jobsAvailable_.wait(lock, [queue]() { return queue->terminate_ || queue->jobsCount_ != 0; });
+        queue->jobs_available_.wait(lock, [queue]() { return queue->terminate_ || queue->jobs_count_ != 0; });
 
         if (queue->terminate_) {
             return;
@@ -111,18 +111,18 @@ void CompileQueue::Worker(CompileQueue *queue)
         lock.unlock();
 
         queue->Consume();
-        queue->jobsFinished_.notify_one();
+        queue->jobs_finished_.notify_one();
     }
 }
 
 void CompileQueue::Consume()
 {
     std::unique_lock<std::mutex> lock(m_);
-    activeWorkers_++;
+    active_workers_++;
 
-    while (jobsCount_ > 0) {
-        --jobsCount_;
-        auto &job = jobs_[jobsCount_];
+    while (jobs_count_ > 0) {
+        --jobs_count_;
+        auto &job = jobs_[jobs_count_];
 
         lock.unlock();
 
@@ -137,13 +137,13 @@ void CompileQueue::Consume()
         lock.lock();
     }
 
-    activeWorkers_--;
+    active_workers_--;
 }
 
 void CompileQueue::Wait()
 {
     std::unique_lock<std::mutex> lock(m_);
-    jobsFinished_.wait(lock, [this]() { return activeWorkers_ == 0 && jobsCount_ == 0; });
+    jobs_finished_.wait(lock, [this]() { return active_workers_ == 0 && jobs_count_ == 0; });
     delete[] jobs_;
 
     if (!errors_.empty()) {
diff --git a/compiler/core/compileQueue.h b/compiler/core/compileQueue.h
index 5e227475ba26c314078b5d5f4108a8b5c069ee63..0499a66cf700c9d7cb1b2dd9ae19bce5f5fdaf4f 100644
--- a/compiler/core/compileQueue.h
+++ b/compiler/core/compileQueue.h
@@ -79,11 +79,11 @@ private:
     std::vector<os::thread::native_handle_type> threads_;
     std::vector<Error> errors_;
     std::mutex m_;
-    std::condition_variable jobsAvailable_;
-    std::condition_variable jobsFinished_;
+    std::condition_variable jobs_available_;
+    std::condition_variable jobs_finished_;
     CompileJob *jobs_ {};
-    size_t jobsCount_ {0};
-    size_t activeWorkers_ {0};
+    size_t jobs_count_ {0};
+    size_t active_workers_ {0};
     bool terminate_ {false};
 };
 
diff --git a/compiler/core/compilerContext.cpp b/compiler/core/compilerContext.cpp
index 6a97c410fdd32e9a6b48274c4700ec069553893c..35c62d4678357a3c4a00247b710ca81c8977acab 100644
--- a/compiler/core/compilerContext.cpp
+++ b/compiler/core/compilerContext.cpp
@@ -20,7 +20,7 @@
 namespace panda::es2panda::compiler {
 
 CompilerContext::CompilerContext(binder::Binder *binder, bool isDebug)
-    : binder_(binder), emitter_(std::make_unique<class Emitter>(this)), isDebug_(isDebug)
+    : binder_(binder), emitter_(std::make_unique<class Emitter>(this)), is_debug_(isDebug)
 {
 }
 
diff --git a/compiler/core/compilerContext.h b/compiler/core/compilerContext.h
index 517163ae62d861c45600c38321c9780a62103e3a..90a97fa6d08142fbabb146cc8224dc5f1c1e0d86 100644
--- a/compiler/core/compilerContext.h
+++ b/compiler/core/compilerContext.h
@@ -50,13 +50,13 @@ public:
 
     int32_t LiteralCount() const
     {
-        return literalBufferIdx_;
+        return literal_buffer_idx_;
     }
 
     int32_t NewLiteralIndex()
     {
         std::lock_guard lock(m_);
-        return literalBufferIdx_++;
+        return literal_buffer_idx_++;
     }
 
     std::mutex &Mutex()
@@ -66,15 +66,15 @@ public:
 
     bool IsDebug() const
     {
-        return isDebug_;
+        return is_debug_;
     }
 
 private:
     binder::Binder *binder_;
     std::unique_ptr<Emitter> emitter_;
-    int32_t literalBufferIdx_ {0};
+    int32_t literal_buffer_idx_ {0};
     std::mutex m_;
-    bool isDebug_;
+    bool is_debug_;
 };
 
 }  // namespace panda::es2panda::compiler
diff --git a/compiler/core/compilerImpl.cpp b/compiler/core/compilerImpl.cpp
index c4ff569b2a7da04f7405cbb0f76ded8ea043606e..32d523844a1c9876bd6c4cf90602ef2eec8a57b9 100644
--- a/compiler/core/compilerImpl.cpp
+++ b/compiler/core/compilerImpl.cpp
@@ -36,7 +36,7 @@ CompilerImpl::~CompilerImpl()
 
 panda::pandasm::Program *CompilerImpl::Compile(parser::Program *program, const es2panda::CompilerOptions &options)
 {
-    CompilerContext context(program->Binder(), options.isDebug);
+    CompilerContext context(program->Binder(), options.is_debug_);
 
     if (program->Extension() == ScriptExtension::TS) {
         ArenaAllocator localAllocator(SpaceType::SPACE_TYPE_COMPILER, nullptr, true);
@@ -53,7 +53,7 @@ panda::pandasm::Program *CompilerImpl::Compile(parser::Program *program, const e
     queue_->Consume();
     queue_->Wait();
 
-    return context.GetEmitter()->Finalize(options.dumpDebugInfo);
+    return context.GetEmitter()->Finalize(options.dump_debug_info_);
 }
 
 void CompilerImpl::DumpAsm(const panda::pandasm::Program *prog)
diff --git a/compiler/core/dynamicContext.cpp b/compiler/core/dynamicContext.cpp
index 73e9e9ddcb08b589c09a48c9d822fe1497086fb4..936ff81aaf3109aebaec2d0b992cbd1484720980 100644
--- a/compiler/core/dynamicContext.cpp
+++ b/compiler/core/dynamicContext.cpp
@@ -23,18 +23,19 @@
 #include <ir/statements/labelledStatement.h>
 
 namespace panda::es2panda::compiler {
-DynamicContext::DynamicContext(PandaGen *pg, LabelTarget target) : pg_(pg), target_(target), prev_(pg_->dynamicContext_)
+DynamicContext::DynamicContext(PandaGen *pg, LabelTarget target)
+    : pg_(pg), target_(target), prev_(pg_->dynamic_context_)
 {
-    pg_->dynamicContext_ = this;
+    pg_->dynamic_context_ = this;
 }
 
 DynamicContext::~DynamicContext()
 {
-    pg_->dynamicContext_ = prev_;
+    pg_->dynamic_context_ = prev_;
 }
 
 LabelContext::LabelContext(PandaGen *pg, const ir::LabelledStatement *labelledStmt)
-    : DynamicContext(pg, LabelTarget(labelledStmt->Ident()->Name())), labelledStmt_(labelledStmt)
+    : DynamicContext(pg, LabelTarget(labelledStmt->Ident()->Name())), labelled_stmt_(labelledStmt)
 {
     if (!labelledStmt->Body()->IsBlockStatement()) {
         return;
@@ -50,31 +51,31 @@ LabelContext::~LabelContext()
         return;
     }
 
-    pg_->SetLabel(labelledStmt_, label_);
+    pg_->SetLabel(labelled_stmt_, label_);
 }
 
 LexEnvContext::LexEnvContext(LoopEnvScope *envScope, PandaGen *pg, LabelTarget target)
-    : DynamicContext(pg, target), envScope_(envScope)
+    : DynamicContext(pg, target), env_scope_(envScope)
 {
-    if (!envScope_->HasEnv()) {
+    if (!env_scope_->HasEnv()) {
         return;
     }
 
-    catchTable_ = pg_->CreateCatchTable();
-    const auto &labelSet = catchTable_->LabelSet();
-    const auto *node = envScope_->Scope()->Node();
+    catch_table_ = pg_->CreateCatchTable();
+    const auto &labelSet = catch_table_->LabelSet();
+    const auto *node = env_scope_->Scope()->Node();
 
     pg_->SetLabel(node, labelSet.TryBegin());
 }
 
 LexEnvContext::~LexEnvContext()
 {
-    if (!envScope_->HasEnv()) {
+    if (!env_scope_->HasEnv()) {
         return;
     }
 
-    const auto &labelSet = catchTable_->LabelSet();
-    const auto *node = envScope_->Scope()->Node();
+    const auto &labelSet = catch_table_->LabelSet();
+    const auto *node = env_scope_->Scope()->Node();
 
     pg_->SetLabel(node, labelSet.TryEnd());
     pg_->Branch(node, labelSet.CatchEnd());
@@ -88,30 +89,30 @@ LexEnvContext::~LexEnvContext()
 
 bool LexEnvContext::HasTryCatch() const
 {
-    return envScope_->HasEnv();
+    return env_scope_->HasEnv();
 }
 
 void LexEnvContext::AbortContext([[maybe_unused]] ControlFlowChange cfc,
                                  [[maybe_unused]] const util::StringView &targetLabel)
 {
-    if (cfc == ControlFlowChange::CONTINUE || !envScope_->HasEnv()) {
+    if (cfc == ControlFlowChange::CONTINUE || !env_scope_->HasEnv()) {
         return;
     }
 
-    const auto *node = envScope_->Scope()->Node();
+    const auto *node = env_scope_->Scope()->Node();
     pg_->PopLexEnv(node);
 }
 
 IteratorContext::IteratorContext(PandaGen *pg, const Iterator &iterator, LabelTarget target)
-    : DynamicContext(pg, target), iterator_(iterator), catchTable_(pg->CreateCatchTable())
+    : DynamicContext(pg, target), iterator_(iterator), catch_table_(pg->CreateCatchTable())
 {
-    const auto &labelSet = catchTable_->LabelSet();
+    const auto &labelSet = catch_table_->LabelSet();
     pg_->SetLabel(iterator_.Node(), labelSet.TryBegin());
 }
 
 IteratorContext::~IteratorContext()
 {
-    const auto &labelSet = catchTable_->LabelSet();
+    const auto &labelSet = catch_table_->LabelSet();
     const auto *node = iterator_.Node();
 
     pg_->SetLabel(node, labelSet.TryEnd());
@@ -134,40 +135,40 @@ void IteratorContext::AbortContext([[maybe_unused]] ControlFlowChange cfc,
 
 void TryContext::InitFinalizer()
 {
-    ASSERT(tryStmt_);
+    ASSERT(try_stmt_);
 
-    if (!hasFinalizer_ || !tryStmt_->FinallyBlock()) {
+    if (!has_finalizer_ || !try_stmt_->FinallyBlock()) {
         return;
     }
 
-    finalizerRun_ = pg_->AllocReg();
-    pg_->StoreConst(tryStmt_, finalizerRun_, Constant::JS_UNDEFINED);
+    finalizer_run_ = pg_->AllocReg();
+    pg_->StoreConst(try_stmt_, finalizer_run_, Constant::JS_UNDEFINED);
 }
 
 void TryContext::InitCatchTable()
 {
-    catchTable_ = pg_->CreateCatchTable();
+    catch_table_ = pg_->CreateCatchTable();
 }
 
 const TryLabelSet &TryContext::LabelSet() const
 {
-    return catchTable_->LabelSet();
+    return catch_table_->LabelSet();
 }
 
 bool TryContext::HasFinalizer() const
 {
-    return hasFinalizer_;
+    return has_finalizer_;
 }
 
 void TryContext::EmitFinalizer()
 {
-    if (!hasFinalizer_ || inFinalizer_ || !tryStmt_->FinallyBlock()) {
+    if (!has_finalizer_ || in_finalizer_ || !try_stmt_->FinallyBlock()) {
         return;
     }
 
-    inFinalizer_ = true;
-    tryStmt_->FinallyBlock()->Compile(pg_);
-    inFinalizer_ = false;
+    in_finalizer_ = true;
+    try_stmt_->FinallyBlock()->Compile(pg_);
+    in_finalizer_ = false;
 }
 
 void TryContext::AbortContext([[maybe_unused]] ControlFlowChange cfc,
diff --git a/compiler/core/dynamicContext.h b/compiler/core/dynamicContext.h
index 2e13faab6e9ab022393fa06168150f4af0fa2590..cb766aacfbb643adbe98f8437800cd6745a6fa9a 100644
--- a/compiler/core/dynamicContext.h
+++ b/compiler/core/dynamicContext.h
@@ -97,7 +97,7 @@ public:
 
 private:
     Label *label_ {};
-    const ir::LabelledStatement *labelledStmt_ {};
+    const ir::LabelledStatement *labelled_stmt_ {};
 };
 
 class LexEnvContext : public DynamicContext {
@@ -117,8 +117,8 @@ public:
                       [[maybe_unused]] const util::StringView &targetLabel) override;
 
 private:
-    LoopEnvScope *envScope_;
-    CatchTable *catchTable_ {};
+    LoopEnvScope *env_scope_;
+    CatchTable *catch_table_ {};
 };
 
 class IteratorContext : public DynamicContext {
@@ -148,13 +148,13 @@ public:
 
 private:
     const Iterator &iterator_;
-    CatchTable *catchTable_;
+    CatchTable *catch_table_;
 };
 
 class TryContext : public DynamicContext {
 public:
     explicit TryContext(PandaGen *pg, const ir::TryStatement *tryStmt, bool hasFinalizer = true)
-        : DynamicContext(pg, {}), tryStmt_(tryStmt), hasFinalizer_(hasFinalizer)
+        : DynamicContext(pg, {}), try_stmt_(tryStmt), has_finalizer_(hasFinalizer)
     {
         InitCatchTable();
         InitFinalizer();
@@ -181,12 +181,12 @@ public:
 
     VReg FinalizerRun() const
     {
-        return finalizerRun_;
+        return finalizer_run_;
     }
 
     CatchTable *GetCatchTable() const
     {
-        return catchTable_;
+        return catch_table_;
     }
 
     const TryLabelSet &LabelSet() const;
@@ -200,11 +200,11 @@ public:
 private:
     void InitCatchTable();
 
-    const ir::TryStatement *tryStmt_ {};
-    CatchTable *catchTable_ {};
-    VReg finalizerRun_ {};
-    bool hasFinalizer_ {};
-    bool inFinalizer_ {};
+    const ir::TryStatement *try_stmt_ {};
+    CatchTable *catch_table_ {};
+    VReg finalizer_run_ {};
+    bool has_finalizer_ {};
+    bool in_finalizer_ {};
 };
 }  // namespace panda::es2panda::compiler
 
diff --git a/compiler/core/emitter.cpp b/compiler/core/emitter.cpp
index 6e617cb41f196d3b1ae3fdc361eed462f28af155..86826b88145c94f448239b2a84215a8a6ea5e032 100644
--- a/compiler/core/emitter.cpp
+++ b/compiler/core/emitter.cpp
@@ -41,19 +41,19 @@ namespace panda::es2panda::compiler {
 constexpr const auto LANG_EXT = panda::pandasm::extensions::Language::ECMASCRIPT;
 
 FunctionEmitter::FunctionEmitter(ArenaAllocator *allocator, const PandaGen *pg)
-    : pg_(pg), literalBuffers_(allocator->Adapter())
+    : pg_(pg), literal_buffers_(allocator->Adapter())
 {
     func_ = allocator->New<panda::pandasm::Function>(pg->InternalName().Mutf8(), LANG_EXT);
 
     size_t paramCount = pg->InternalParamCount();
-    func_->params.reserve(paramCount);
+    func_->params_.reserve(paramCount);
 
     for (uint32_t i = 0; i < paramCount; ++i) {
-        func_->params.emplace_back(panda::pandasm::Type("any", 0), LANG_EXT);
+        func_->params_.emplace_back(panda::pandasm::Type("any", 0), LANG_EXT);
     }
 
-    func_->regs_num = pg->TotalRegsNum();
-    func_->return_type = panda::pandasm::Type("any", 0);
+    func_->regs_num_ = pg->TotalRegsNum();
+    func_->return_type_ = panda::pandasm::Type("any", 0);
 }
 
 void FunctionEmitter::Generate()
@@ -73,7 +73,7 @@ const ArenaSet<util::StringView> &FunctionEmitter::Strings() const
 
 void FunctionEmitter::GenBufferLiterals(const LiteralBuffer *buff)
 {
-    auto &[idx, array] = literalBuffers_.emplace_back();
+    auto &[idx, array] = literal_buffers_.emplace_back();
     idx = buff->Index();
     array.reserve(buff->Literals().size() * 2);
 
@@ -192,7 +192,7 @@ static size_t GetIRNodeWholeLength(const IRNode *node)
 
 static std::string WholeLine(const util::StringView &source, lexer::SourceRange range)
 {
-    return source.Substr(range.start.index, range.end.index).EscapeSymbol<util::StringView::Mutf8Encode>();
+    return source.Substr(range.start_.index_, range.end_.index_).EscapeSymbol<util::StringView::Mutf8Encode>();
 }
 
 void FunctionEmitter::GenInstructionDebugInfo(const IRNode *ins, panda::pandasm::Ins *pandaIns)
@@ -202,32 +202,32 @@ void FunctionEmitter::GenInstructionDebugInfo(const IRNode *ins, panda::pandasm:
     ASSERT(astNode != nullptr);
 
     if (astNode == FIRST_NODE_OF_FUNCTION) {
-        astNode = pg_->Debuginfo().firstStmt;
+        astNode = pg_->Debuginfo().first_stmt_;
         if (!astNode) {
             return;
         }
     }
 
-    pandaIns->ins_debug.line_number = astNode->Range().start.line + 1;
+    pandaIns->ins_debug_.line_number_ = astNode->Range().start_.line_ + 1;
 
     if (pg_->IsDebug()) {
         size_t insLen = GetIRNodeWholeLength(ins);
         if (insLen != 0) {
-            pandaIns->ins_debug.bound_left = offset_;
-            pandaIns->ins_debug.bound_right = offset_ + insLen;
+            pandaIns->ins_debug_.bound_left_ = offset_;
+            pandaIns->ins_debug_.bound_right_ = offset_ + insLen;
         }
 
         offset_ += insLen;
-        pandaIns->ins_debug.whole_line = WholeLine(SourceCode(), astNode->Range());
+        pandaIns->ins_debug_.whole_line_ = WholeLine(SourceCode(), astNode->Range());
     }
 }
 
 void FunctionEmitter::GenFunctionInstructions()
 {
-    func_->ins.reserve(pg_->Insns().size());
+    func_->ins_.reserve(pg_->Insns().size());
 
     for (const auto *ins : pg_->Insns()) {
-        auto &pandaIns = func_->ins.emplace_back();
+        auto &pandaIns = func_->ins_.emplace_back();
 
         ins->Transform(&pandaIns);
         GenInstructionDebugInfo(ins, &pandaIns);
@@ -254,21 +254,21 @@ void FunctionEmitter::GenFunctionICSize()
             panda::pandasm::ScalarValue::Create<panda::pandasm::Value::Type::STRING>(pg_->FunctionName().Mutf8())));
     funcAnnotationData.AddElement(std::move(funcNameAnnotationElement));
 
-    func_->metadata->AddAnnotations({funcAnnotationData});
+    func_->metadata_->AddAnnotations({funcAnnotationData});
 }
 
 void FunctionEmitter::GenFunctionCatchTables()
 {
-    func_->catch_blocks.reserve(pg_->CatchList().size());
+    func_->catch_blocks_.reserve(pg_->CatchList().size());
 
     for (const auto *catchBlock : pg_->CatchList()) {
         const auto &labelSet = catchBlock->LabelSet();
 
-        auto &pandaCatchBlock = func_->catch_blocks.emplace_back();
-        pandaCatchBlock.try_begin_label = labelSet.TryBegin()->Id();
-        pandaCatchBlock.try_end_label = labelSet.TryEnd()->Id();
-        pandaCatchBlock.catch_begin_label = labelSet.CatchBegin()->Id();
-        pandaCatchBlock.catch_end_label = labelSet.CatchEnd()->Id();
+        auto &pandaCatchBlock = func_->catch_blocks_.emplace_back();
+        pandaCatchBlock.try_begin_label_ = labelSet.TryBegin()->Id();
+        pandaCatchBlock.try_end_label_ = labelSet.TryEnd()->Id();
+        pandaCatchBlock.catch_begin_label_ = labelSet.CatchBegin()->Id();
+        pandaCatchBlock.catch_end_label_ = labelSet.CatchEnd()->Id();
     }
 }
 
@@ -281,14 +281,14 @@ void FunctionEmitter::GenLiteralBuffers()
 
 void FunctionEmitter::GenSourceFileDebugInfo()
 {
-    func_->source_file = std::string {pg_->Binder()->Program()->SourceFile()};
+    func_->source_file_ = std::string {pg_->Binder()->Program()->SourceFile()};
 
     if (!pg_->IsDebug()) {
         return;
     }
 
     if (pg_->RootNode()->IsProgram()) {
-        func_->source_code = SourceCode().EscapeSymbol<util::StringView::Mutf8Encode>();
+        func_->source_code_ = SourceCode().EscapeSymbol<util::StringView::Mutf8Encode>();
     }
 }
 
@@ -311,13 +311,13 @@ void FunctionEmitter::GenScopeVariableInfo(const binder::Scope *scope)
                     continue;
                 }
 
-                auto &variableDebug = func_->local_variable_debug.emplace_back();
-                variableDebug.name = name.Mutf8();
-                variableDebug.signature = "any";
-                variableDebug.signature_type = "any";
-                variableDebug.reg = static_cast<int32_t>(variable->AsLocalVariable()->Vreg());
-                variableDebug.start = start;
-                variableDebug.length = static_cast<uint32_t>(varsLength);
+                auto &variableDebug = func_->local_variable_debug_.emplace_back();
+                variableDebug.name_ = name.Mutf8();
+                variableDebug.signature_ = "any";
+                variableDebug.signature_type_ = "any";
+                variableDebug.reg_ = static_cast<int32_t>(variable->AsLocalVariable()->Vreg());
+                variableDebug.start_ = start;
+                variableDebug.length_ = static_cast<uint32_t>(varsLength);
             }
 
             break;
@@ -333,7 +333,7 @@ void FunctionEmitter::GenVariablesDebugInfo()
         return;
     }
 
-    for (const auto *scope : pg_->Debuginfo().variableDebugInfo) {
+    for (const auto *scope : pg_->Debuginfo().variable_debug_info_) {
         GenScopeVariableInfo(scope);
     }
 }
@@ -343,9 +343,9 @@ void FunctionEmitter::GenVariablesDebugInfo()
 Emitter::Emitter(const CompilerContext *context)
 {
     prog_ = new panda::pandasm::Program();
-    prog_->lang = panda::pandasm::extensions::Language::ECMASCRIPT;
+    prog_->lang_ = panda::pandasm::extensions::Language::ECMASCRIPT;
 
-    prog_->function_table.reserve(context->Binder()->Functions().size());
+    prog_->function_table_.reserve(context->Binder()->Functions().size());
     GenESAnnoatationRecord();
     GenESModuleModeRecord(context->Binder()->Program()->Kind() == parser::ScriptKind::MODULE);
 }
@@ -358,25 +358,25 @@ Emitter::~Emitter()
 void Emitter::GenESAnnoatationRecord()
 {
     auto annotationRecord = panda::pandasm::Record("_ESAnnotation", LANG_EXT);
-    annotationRecord.metadata->SetAttribute("external");
-    annotationRecord.metadata->SetAccessFlags(panda::ACC_ANNOTATION);
-    prog_->record_table.emplace(annotationRecord.name, std::move(annotationRecord));
+    annotationRecord.metadata_->SetAttribute("external");
+    annotationRecord.metadata_->SetAccessFlags(panda::ACC_ANNOTATION);
+    prog_->record_table_.emplace(annotationRecord.name_, std::move(annotationRecord));
 }
 
 void Emitter::GenESModuleModeRecord(bool isModule)
 {
     auto modeRecord = panda::pandasm::Record("_ESModuleMode", LANG_EXT);
-    modeRecord.metadata->SetAccessFlags(panda::ACC_PUBLIC);
+    modeRecord.metadata_->SetAccessFlags(panda::ACC_PUBLIC);
 
     auto modeField = panda::pandasm::Field(LANG_EXT);
-    modeField.name = "isModule";
-    modeField.type = panda::pandasm::Type("u8", 0);
-    modeField.metadata->SetValue(
+    modeField.name_ = "isModule";
+    modeField.type_ = panda::pandasm::Type("u8", 0);
+    modeField.metadata_->SetValue(
         panda::pandasm::ScalarValue::Create<panda::pandasm::Value::Type::U8>(static_cast<uint8_t>(isModule)));
 
-    modeRecord.field_list.emplace_back(std::move(modeField));
+    modeRecord.field_list_.emplace_back(std::move(modeField));
 
-    prog_->record_table.emplace(modeRecord.name, std::move(modeRecord));
+    prog_->record_table_.emplace(modeRecord.name_, std::move(modeRecord));
 }
 
 void Emitter::AddFunction(FunctionEmitter *func)
@@ -384,16 +384,16 @@ void Emitter::AddFunction(FunctionEmitter *func)
     std::lock_guard<std::mutex> lock(m_);
 
     for (const auto &str : func->Strings()) {
-        prog_->strings.insert(str.Mutf8());
+        prog_->strings_.insert(str.Mutf8());
     }
 
     for (auto &[idx, buf] : func->LiteralBuffers()) {
         auto literalArrayInstance = panda::pandasm::LiteralArray(std::move(buf));
-        prog_->literalarray_table.emplace(std::to_string(idx), std::move(literalArrayInstance));
+        prog_->literalarray_table_.emplace(std::to_string(idx), std::move(literalArrayInstance));
     }
 
     auto *function = func->Function();
-    prog_->function_table.emplace(function->name, std::move(*function));
+    prog_->function_table_.emplace(function->name_, std::move(*function));
 }
 
 void Emitter::DumpAsm(const panda::pandasm::Program *prog)
@@ -402,7 +402,7 @@ void Emitter::DumpAsm(const panda::pandasm::Program *prog)
 
     ss << ".language ECMAScript" << std::endl << std::endl;
 
-    for (auto &[name, func] : prog->function_table) {
+    for (auto &[name, func] : prog->function_table_) {
         ss << ".function any " << name << '(';
 
         for (uint32_t i = 0; i < func.GetParamsNum(); i++) {
@@ -415,14 +415,14 @@ void Emitter::DumpAsm(const panda::pandasm::Program *prog)
 
         ss << ") {" << std::endl;
 
-        for (const auto &ins : func.ins) {
-            ss << (ins.set_label ? "" : "\t") << ins.ToString("", true, func.GetTotalRegs()) << std::endl;
+        for (const auto &ins : func.ins_) {
+            ss << (ins.set_label_ ? "" : "\t") << ins.ToString("", true, func.GetTotalRegs()) << std::endl;
         }
 
         ss << "}" << std::endl << std::endl;
 
-        for (const auto &ct : func.catch_blocks) {
-            ss << ".catchall " << ct.try_begin_label << ", " << ct.try_end_label << ", " << ct.catch_begin_label
+        for (const auto &ct : func.catch_blocks_) {
+            ss << ".catchall " << ct.try_begin_label_ << ", " << ct.try_end_label_ << ", " << ct.catch_begin_label_
                << std::endl
                << std::endl;
         }
diff --git a/compiler/core/emitter.h b/compiler/core/emitter.h
index addf4b142b4daaeb21c86c5edcf424de01ea2c0b..176601b46bc299d675965670cba06e2188b51067 100644
--- a/compiler/core/emitter.h
+++ b/compiler/core/emitter.h
@@ -66,7 +66,7 @@ public:
 
     auto &LiteralBuffers()
     {
-        return literalBuffers_;
+        return literal_buffers_;
     }
 
     void Generate();
@@ -87,7 +87,7 @@ private:
 
     const PandaGen *pg_;
     panda::pandasm::Function *func_ {};
-    ArenaVector<std::pair<int32_t, std::vector<panda::pandasm::LiteralArray::Literal>>> literalBuffers_;
+    ArenaVector<std::pair<int32_t, std::vector<panda::pandasm::LiteralArray::Literal>>> literal_buffers_;
     size_t offset_ {0};
 };
 
diff --git a/compiler/core/envScope.cpp b/compiler/core/envScope.cpp
index 6e2fa13c78c7038bb1a0d4e2a0eb7405af141868..5d5c643a6e2e350d1ad72144a4352ee3fe6b9a08 100644
--- a/compiler/core/envScope.cpp
+++ b/compiler/core/envScope.cpp
@@ -20,22 +20,22 @@
 
 namespace panda::es2panda::compiler {
 
-ScopeContext::ScopeContext(PandaGen *pg, binder::Scope *newScope) : pg_(pg), prevScope_(pg_->scope_)
+ScopeContext::ScopeContext(PandaGen *pg, binder::Scope *newScope) : pg_(pg), prev_scope_(pg_->scope_)
 {
     pg_->scope_ = newScope;
 }
 
 ScopeContext::~ScopeContext()
 {
-    pg_->scope_ = prevScope_;
+    pg_->scope_ = prev_scope_;
 }
 
 void EnvScope::Initialize(PandaGen *pg, VReg lexEnv)
 {
     pg_ = pg;
-    prev_ = pg_->envScope_;
-    lexEnv_ = lexEnv;
-    pg_->envScope_ = this;
+    prev_ = pg_->env_scope_;
+    lex_env_ = lexEnv;
+    pg_->env_scope_ = this;
 }
 
 EnvScope::~EnvScope()
@@ -44,7 +44,7 @@ EnvScope::~EnvScope()
         return;
     }
 
-    pg_->envScope_ = prev_;
+    pg_->env_scope_ = prev_;
 }
 
 void LoopEnvScope::CopyBindings(PandaGen *pg, binder::VariableScope *scope, binder::VariableFlags flag)
@@ -56,7 +56,7 @@ void LoopEnvScope::CopyBindings(PandaGen *pg, binder::VariableScope *scope, bind
     Initialize(pg, pg->AllocReg());
 
     pg_->NewLexEnv(scope_->Node(), scope->LexicalSlots());
-    pg_->StoreAccumulator(scope_->Node(), lexEnv_);
+    pg_->StoreAccumulator(scope_->Node(), lex_env_);
 
     ASSERT(scope->NeedLexEnv());
 
@@ -78,7 +78,7 @@ void LoopEnvScope::CopyPetIterationCtx()
     }
 
     pg_->CopyLexEnv(scope_->Node());
-    pg_->StoreAccumulator(scope_->Node(), lexEnv_);
+    pg_->StoreAccumulator(scope_->Node(), lex_env_);
 }
 
 }  // namespace panda::es2panda::compiler
diff --git a/compiler/core/envScope.h b/compiler/core/envScope.h
index 55b801a7a1f3e026a9403344d896fdbedc68ecbe..0d9bdcbb5d08cc057fc94e324eb115b4497b8666 100644
--- a/compiler/core/envScope.h
+++ b/compiler/core/envScope.h
@@ -41,7 +41,7 @@ public:
 
 private:
     PandaGen *pg_;
-    binder::Scope *prevScope_;
+    binder::Scope *prev_scope_;
 };
 
 class EnvScope {
@@ -56,7 +56,7 @@ public:
 
     VReg LexEnv() const
     {
-        return lexEnv_;
+        return lex_env_;
     }
 
     EnvScope *Prev() const
@@ -69,25 +69,25 @@ protected:
 
     PandaGen *pg_ {};
     EnvScope *prev_ {};
-    VReg lexEnv_ {};
+    VReg lex_env_ {};
 };
 
 class LoopEnvScope : public EnvScope {
 public:
     explicit LoopEnvScope(PandaGen *pg, binder::LoopScope *scope, LabelTarget target)
-        : scope_(NeedEnv(scope) ? scope : nullptr), regScope_(pg, scope), lexEnvCtx_(this, pg, target)
+        : scope_(NeedEnv(scope) ? scope : nullptr), reg_scope_(pg, scope), lex_env_ctx_(this, pg, target)
     {
         CopyBindings(pg, scope, binder::VariableFlags::PER_ITERATION);
     }
 
     explicit LoopEnvScope(PandaGen *pg, LabelTarget target, binder::LoopScope *scope)
-        : scope_(NeedEnv(scope) ? scope : nullptr), regScope_(pg), lexEnvCtx_(this, pg, target)
+        : scope_(NeedEnv(scope) ? scope : nullptr), reg_scope_(pg), lex_env_ctx_(this, pg, target)
     {
         CopyBindings(pg, scope, binder::VariableFlags::PER_ITERATION);
     }
 
     explicit LoopEnvScope(PandaGen *pg, binder::LoopDeclarationScope *scope)
-        : scope_(NeedEnv(scope) ? scope : nullptr), regScope_(pg), lexEnvCtx_(this, pg, {})
+        : scope_(NeedEnv(scope) ? scope : nullptr), reg_scope_(pg), lex_env_ctx_(this, pg, {})
     {
         CopyBindings(pg, scope, binder::VariableFlags::LOOP_DECL);
     }
@@ -114,8 +114,8 @@ private:
     void CopyBindings(PandaGen *pg, binder::VariableScope *scope, binder::VariableFlags flag);
 
     binder::VariableScope *scope_ {};
-    LocalRegScope regScope_;
-    LexEnvContext lexEnvCtx_;
+    LocalRegScope reg_scope_;
+    LexEnvContext lex_env_ctx_;
 };
 
 }  // namespace panda::es2panda::compiler
diff --git a/compiler/core/labelTarget.cpp b/compiler/core/labelTarget.cpp
index 3fc9530fa07e3b66cd8c6e982274efeee2cfc3b1..38f386c377f4e4d414919b3ea25fa4b975155618 100644
--- a/compiler/core/labelTarget.cpp
+++ b/compiler/core/labelTarget.cpp
@@ -20,7 +20,7 @@
 namespace panda::es2panda::compiler {
 
 LabelTarget::LabelTarget(PandaGen *pg)
-    : LabelPair(pg->AllocLabel(), pg->AllocLabel()), breakLabel_(BREAK_LABEL), continueLabel_(CONTINUE_LABEL)
+    : LabelPair(pg->AllocLabel(), pg->AllocLabel()), break_label_(BREAK_LABEL), continue_label_(CONTINUE_LABEL)
 {
 }
 
diff --git a/compiler/core/labelTarget.h b/compiler/core/labelTarget.h
index 6c9ee9792b458ad55d9721d3b82c47d7786d2e14..e8fe4c4b7b868774a0f09e441ed07a9969de33a4 100644
--- a/compiler/core/labelTarget.h
+++ b/compiler/core/labelTarget.h
@@ -41,7 +41,7 @@ public:
     explicit LabelTarget(PandaGen *pg);
     explicit LabelTarget(const util::StringView &label) : LabelTarget(nullptr, label) {}
     explicit LabelTarget(Label *target, const util::StringView &label)
-        : LabelPair(target, nullptr), breakLabel_(label), continueLabel_(label)
+        : LabelPair(target, nullptr), break_label_(label), continue_label_(label)
     {
     }
     LabelTarget() : LabelPair(nullptr, nullptr) {};
@@ -52,7 +52,7 @@ public:
 
     const util::StringView &BreakLabel() const
     {
-        return breakLabel_;
+        return break_label_;
     }
 
     Label *BreakTarget() const
@@ -67,7 +67,7 @@ public:
 
     const util::StringView &ContinueLabel() const
     {
-        return continueLabel_;
+        return continue_label_;
     }
 
     Label *ContinueTarget() const
@@ -79,8 +79,8 @@ public:
     static constexpr std::string_view CONTINUE_LABEL = "#c";
 
 private:
-    util::StringView breakLabel_ {};
-    util::StringView continueLabel_ {};
+    util::StringView break_label_ {};
+    util::StringView continue_label_ {};
 };
 
 }  // namespace panda::es2panda::compiler
diff --git a/compiler/core/pandagen.cpp b/compiler/core/pandagen.cpp
index d4ff04eef6ad84d07c63c3b264d6773894c70c77..c675521faa477bf8460fc4346b37c37bdf4ac8bd 100644
--- a/compiler/core/pandagen.cpp
+++ b/compiler/core/pandagen.cpp
@@ -44,7 +44,7 @@ namespace panda::es2panda::compiler {
 
 Label *PandaGen::AllocLabel()
 {
-    std::string id = std::string {Label::PREFIX} + std::to_string(labelId_++);
+    std::string id = std::string {Label::PREFIX} + std::to_string(label_id_++);
     return sa_.AllocLabel(std::move(id));
 }
 
@@ -55,22 +55,22 @@ bool PandaGen::IsDebug() const
 
 uint32_t PandaGen::ParamCount() const
 {
-    if (rootNode_->IsProgram()) {
+    if (root_node_->IsProgram()) {
         return 0;
     }
 
-    return rootNode_->AsScriptFunction()->Params().size();
+    return root_node_->AsScriptFunction()->Params().size();
 }
 
 uint32_t PandaGen::FormalParametersCount() const
 {
-    if (rootNode_->IsProgram()) {
+    if (root_node_->IsProgram()) {
         return 0;
     }
 
-    ASSERT(rootNode_->IsScriptFunction());
+    ASSERT(root_node_->IsScriptFunction());
 
-    return rootNode_->AsScriptFunction()->FormalParamsLength();
+    return root_node_->AsScriptFunction()->FormalParamsLength();
 }
 
 uint32_t PandaGen::InternalParamCount() const
@@ -81,12 +81,12 @@ uint32_t PandaGen::InternalParamCount() const
 
 const util::StringView &PandaGen::InternalName() const
 {
-    return topScope_->InternalName();
+    return top_scope_->InternalName();
 }
 
 const util::StringView &PandaGen::FunctionName() const
 {
-    return topScope_->Name();
+    return top_scope_->Name();
 }
 
 binder::Binder *PandaGen::Binder() const
@@ -96,12 +96,12 @@ binder::Binder *PandaGen::Binder() const
 
 void PandaGen::FunctionInit(CatchTable *catchTable)
 {
-    if (rootNode_->IsProgram()) {
+    if (root_node_->IsProgram()) {
         builder_ = allocator_->New<FunctionBuilder>(this, catchTable);
         return;
     }
 
-    const ir::ScriptFunction *func = rootNode_->AsScriptFunction();
+    const ir::ScriptFunction *func = root_node_->AsScriptFunction();
 
     if (func->IsAsync()) {
         if (func->IsGenerator()) {
@@ -123,31 +123,31 @@ void PandaGen::FunctionInit(CatchTable *catchTable)
 
 bool PandaGen::FunctionHasFinalizer() const
 {
-    if (rootNode_->IsProgram()) {
+    if (root_node_->IsProgram()) {
         return false;
     }
 
-    const ir::ScriptFunction *func = rootNode_->AsScriptFunction();
+    const ir::ScriptFunction *func = root_node_->AsScriptFunction();
 
     return func->IsAsync() || func->IsGenerator();
 }
 
 void PandaGen::FunctionEnter()
 {
-    builder_->Prepare(rootNode_->AsScriptFunction());
+    builder_->Prepare(root_node_->AsScriptFunction());
 }
 
 void PandaGen::FunctionExit()
 {
-    builder_->CleanUp(rootNode_->AsScriptFunction());
+    builder_->CleanUp(root_node_->AsScriptFunction());
 }
 
 void PandaGen::InitializeLexEnv(const ir::AstNode *node, VReg lexEnv)
 {
     FrontAllocator fa(this);
 
-    if (topScope_->NeedLexEnv()) {
-        NewLexEnv(node, topScope_->LexicalSlots());
+    if (top_scope_->NeedLexEnv()) {
+        NewLexEnv(node, top_scope_->LexicalSlots());
     } else {
         LdLexEnv(node);
     }
@@ -158,9 +158,9 @@ void PandaGen::InitializeLexEnv(const ir::AstNode *node, VReg lexEnv)
 void PandaGen::CopyFunctionArguments(const ir::AstNode *node)
 {
     FrontAllocator fa(this);
-    VReg targetReg = totalRegs_;
+    VReg targetReg = total_regs_;
 
-    for (const auto *param : topScope_->ParamScope()->Params()) {
+    for (const auto *param : top_scope_->ParamScope()->Params()) {
         if (param->LexicalBound()) {
             LoadAccumulator(node, targetReg++);
             StoreLexicalVar(node, 0, param->LexIdx());
@@ -177,7 +177,7 @@ LiteralBuffer *PandaGen::NewLiteralBuffer()
 
 int32_t PandaGen::AddLiteralBuffer(LiteralBuffer *buf)
 {
-    buffStorage_.push_back(buf);
+    buff_storage_.push_back(buf);
     buf->SetIndex(context_->NewLiteralIndex());
     return buf->Index();
 }
@@ -204,10 +204,10 @@ void PandaGen::SetThis(const ir::AstNode *node)
 
 void PandaGen::LoadVar(const ir::Identifier *node, const binder::ScopeFindResult &result)
 {
-    auto *var = result.variable;
+    auto *var = result.variable_;
 
     if (!var) {
-        TryLoadGlobalByName(node, result.name);
+        TryLoadGlobalByName(node, result.name_);
         return;
     }
 
@@ -227,10 +227,10 @@ void PandaGen::LoadVar(const ir::Identifier *node, const binder::ScopeFindResult
 
 void PandaGen::StoreVar(const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDeclaration)
 {
-    binder::Variable *var = result.variable;
+    binder::Variable *var = result.variable_;
 
     if (!var) {
-        TryStoreGlobalByName(node, result.name);
+        TryStoreGlobalByName(node, result.name_);
         return;
     }
 
@@ -262,7 +262,7 @@ void PandaGen::LoadAccFromArgs(const ir::AstNode *node)
     }
 
     binder::ScopeFindResult res = scope_->Find(binder::Binder::FUNCTION_ARGUMENTS);
-    ASSERT(res.scope);
+    ASSERT(res.scope_);
 
     GetUnmappedArgs(node);
     StoreAccToLexEnv(node, res, true);
@@ -421,7 +421,7 @@ void PandaGen::StoreGlobalLet(const ir::AstNode *node, const util::StringView &n
 
 VReg PandaGen::LexEnv() const
 {
-    return envScope_->LexEnv();
+    return env_scope_->LexEnv();
 }
 
 void PandaGen::LoadAccFromLexEnv(const ir::AstNode *node, const binder::ScopeFindResult &result)
@@ -523,7 +523,7 @@ void PandaGen::Branch(const ir::AstNode *node, Label *label)
 
 bool PandaGen::CheckControlFlowChange()
 {
-    const auto *iter = dynamicContext_;
+    const auto *iter = dynamic_context_;
 
     while (iter) {
         if (iter->HasFinalizer()) {
@@ -538,7 +538,7 @@ bool PandaGen::CheckControlFlowChange()
 
 Label *PandaGen::ControlFlowChangeBreak(const ir::Identifier *label)
 {
-    auto *iter = dynamicContext_;
+    auto *iter = dynamic_context_;
 
     util::StringView labelName = label ? label->Name() : LabelTarget::BREAK_LABEL;
     Label *breakTarget = nullptr;
@@ -564,7 +564,7 @@ Label *PandaGen::ControlFlowChangeBreak(const ir::Identifier *label)
 
 Label *PandaGen::ControlFlowChangeContinue(const ir::Identifier *label)
 {
-    auto *iter = dynamicContext_;
+    auto *iter = dynamic_context_;
     util::StringView labelName = label ? label->Name() : LabelTarget::CONTINUE_LABEL;
     Label *continueTarget = nullptr;
 
@@ -1428,7 +1428,7 @@ void PandaGen::LdLexEnv(const ir::AstNode *node)
 
 uint32_t PandaGen::TryDepth() const
 {
-    const auto *iter = dynamicContext_;
+    const auto *iter = dynamic_context_;
     uint32_t depth = 0;
 
     while (iter) {
@@ -1445,13 +1445,13 @@ uint32_t PandaGen::TryDepth() const
 CatchTable *PandaGen::CreateCatchTable()
 {
     auto *catchTable = allocator_->New<CatchTable>(this, TryDepth());
-    catchList_.push_back(catchTable);
+    catch_list_.push_back(catchTable);
     return catchTable;
 }
 
 void PandaGen::SortCatchTables()
 {
-    std::sort(catchList_.begin(), catchList_.end(),
+    std::sort(catch_list_.begin(), catch_list_.end(),
               [](const CatchTable *a, const CatchTable *b) { return b->Depth() < a->Depth(); });
 }
 
diff --git a/compiler/core/pandagen.h b/compiler/core/pandagen.h
index ee623bd7fb247d7adb176af4a116a57d9a680fb5..105675e93474a42a3b87dc4bf02571230af67c14 100644
--- a/compiler/core/pandagen.h
+++ b/compiler/core/pandagen.h
@@ -62,13 +62,13 @@ enum class Constant {
 
 class DebugInfo {
 public:
-    explicit DebugInfo(ArenaAllocator *allocator) : variableDebugInfo(allocator->Adapter()) {};
+    explicit DebugInfo(ArenaAllocator *allocator) : variable_debug_info_(allocator->Adapter()) {};
     DEFAULT_COPY_SEMANTIC(DebugInfo);
     DEFAULT_MOVE_SEMANTIC(DebugInfo);
     ~DebugInfo() = default;
 
-    ArenaVector<const binder::Scope *> variableDebugInfo;
-    const ir::Statement *firstStmt {};
+    ArenaVector<const binder::Scope *> variable_debug_info_;
+    const ir::Statement *first_stmt_ {};
 };
 
 class PandaGen {
@@ -76,14 +76,14 @@ public:
     explicit PandaGen(ArenaAllocator *allocator, CompilerContext *context, binder::FunctionScope *scope)
         : allocator_(allocator),
           context_(context),
-          debugInfo_(allocator_),
-          topScope_(scope),
-          scope_(topScope_),
-          rootNode_(scope->Node()),
+          debug_info_(allocator_),
+          top_scope_(scope),
+          scope_(top_scope_),
+          root_node_(scope->Node()),
           insns_(allocator_->Adapter()),
-          catchList_(allocator_->Adapter()),
+          catch_list_(allocator_->Adapter()),
           strings_(allocator_->Adapter()),
-          buffStorage_(allocator_->Adapter()),
+          buff_storage_(allocator_->Adapter()),
           sa_(this),
           ra_(this),
           rra_(this)
@@ -105,12 +105,12 @@ public:
 
     const ArenaVector<CatchTable *> &CatchList() const
     {
-        return catchList_;
+        return catch_list_;
     }
 
     binder::FunctionScope *TopScope() const
     {
-        return topScope_;
+        return top_scope_;
     }
 
     binder::Scope *Scope() const
@@ -120,7 +120,7 @@ public:
 
     const ir::AstNode *RootNode() const
     {
-        return rootNode_;
+        return root_node_;
     }
 
     ArenaList<IRNode *> &Insns()
@@ -135,27 +135,27 @@ public:
 
     VReg AllocReg()
     {
-        return usedRegs_++;
+        return used_regs_++;
     }
 
     VReg NextReg() const
     {
-        return usedRegs_;
+        return used_regs_;
     }
 
     uint32_t TotalRegsNum() const
     {
-        return totalRegs_;
+        return total_regs_;
     }
 
     size_t LabelCount() const
     {
-        return labelId_;
+        return label_id_;
     }
 
     const DebugInfo &Debuginfo() const
     {
-        return debugInfo_;
+        return debug_info_;
     }
 
     FunctionBuilder *FuncBuilder() const
@@ -165,12 +165,12 @@ public:
 
     EnvScope *GetEnvScope() const
     {
-        return envScope_;
+        return env_scope_;
     }
 
     const ArenaVector<compiler::LiteralBuffer *> &BuffStorage() const
     {
-        return buffStorage_;
+        return buff_storage_;
     }
 
     uint32_t IcSize() const
@@ -375,7 +375,7 @@ public:
 
     void SetFirstStmt(const ir::Statement *stmt)
     {
-        debugInfo_.firstStmt = stmt;
+        debug_info_.first_stmt_ = stmt;
     }
 
     [[noreturn]] static void Unimplemented()
@@ -387,23 +387,23 @@ private:
     ArenaAllocator *allocator_;
     CompilerContext *context_;
     FunctionBuilder *builder_ {nullptr};
-    DebugInfo debugInfo_;
-    binder::FunctionScope *topScope_;
+    DebugInfo debug_info_;
+    binder::FunctionScope *top_scope_;
     binder::Scope *scope_;
-    const ir::AstNode *rootNode_;
+    const ir::AstNode *root_node_;
     ArenaList<IRNode *> insns_;
-    ArenaVector<CatchTable *> catchList_;
+    ArenaVector<CatchTable *> catch_list_;
     ArenaSet<util::StringView> strings_;
-    ArenaVector<LiteralBuffer *> buffStorage_;
-    EnvScope *envScope_ {};
-    DynamicContext *dynamicContext_ {};
+    ArenaVector<LiteralBuffer *> buff_storage_;
+    EnvScope *env_scope_ {};
+    DynamicContext *dynamic_context_ {};
     InlineCache ic_;
     SimpleAllocator sa_;
     RegAllocator ra_;
     RangeRegAllocator rra_;
 
-    uint32_t usedRegs_ {0};
-    uint32_t totalRegs_ {0};
+    uint32_t used_regs_ {0};
+    uint32_t total_regs_ {0};
     friend class ScopeContext;
     friend class RegScope;
     friend class LocalRegScope;
@@ -413,7 +413,7 @@ private:
     friend class EnvScope;
     friend class LoopEnvScope;
     friend class DynamicContext;
-    size_t labelId_ {0};
+    size_t label_id_ {0};
 };
 }  // namespace panda::es2panda::compiler
 
diff --git a/compiler/core/regAllocator.cpp b/compiler/core/regAllocator.cpp
index 7ed5763f5499b520da2aff1128a28b73cacc06a7..c6b90e157e17110258ecfc66e4cb79a0fc2c38b0 100644
--- a/compiler/core/regAllocator.cpp
+++ b/compiler/core/regAllocator.cpp
@@ -58,7 +58,7 @@ FrontAllocator::~FrontAllocator()
 VReg RegAllocatorBase::Spill(IRNode *ins, VReg reg)
 {
     VReg spillReg = pg_->AllocReg();
-    VReg origin = spillIndex_++;
+    VReg origin = spill_index_++;
 
     Add<MovDyn>(ins->Node(), spillReg, origin);
     Add<MovDyn>(ins->Node(), origin, reg);
@@ -68,9 +68,9 @@ VReg RegAllocatorBase::Spill(IRNode *ins, VReg reg)
 
 void RegAllocatorBase::Restore(IRNode *ins)
 {
-    spillIndex_--;
-    VReg spillReg = spillIndex_;
-    VReg origin = regEnd_ + spillIndex_;
+    spill_index_--;
+    VReg spillReg = spill_index_;
+    VReg origin = reg_end_ + spill_index_;
 
     Add<MovDyn>(ins->Node(), origin, spillReg);
 }
@@ -79,7 +79,7 @@ void RegAllocatorBase::Restore(IRNode *ins)
 
 void RegAllocator::Run(IRNode *ins)
 {
-    ASSERT(spillIndex_ == 0);
+    ASSERT(spill_index_ == 0);
     std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
     auto regCnt = ins->Registers(&regs);
     auto registers = Span<VReg *>(regs.data(), regs.data() + regCnt);
@@ -91,7 +91,7 @@ void RegAllocator::Run(IRNode *ins)
 
     RegScope regScope(pg_);
 
-    regEnd_ = pg_->NextReg();
+    reg_end_ = pg_->NextReg();
 
     for (auto *reg : registers) {
         if (IsRegisterCorrect(reg)) {
@@ -104,7 +104,7 @@ void RegAllocator::Run(IRNode *ins)
 
     PushBack(ins);
 
-    while (spillIndex_ != 0) {
+    while (spill_index_ != 0) {
         Restore(ins);
     }
 }
@@ -113,7 +113,7 @@ void RegAllocator::Run(IRNode *ins)
 
 void RangeRegAllocator::Run(IRNode *ins, VReg rangeStart, size_t argCount)
 {
-    ASSERT(spillIndex_ == 0);
+    ASSERT(spill_index_ == 0);
     const auto rangeEnd = rangeStart + argCount;
 
     std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
@@ -127,7 +127,7 @@ void RangeRegAllocator::Run(IRNode *ins, VReg rangeStart, size_t argCount)
 
     RegScope regScope(pg_);
 
-    regEnd_ = pg_->NextReg();
+    reg_end_ = pg_->NextReg();
 
     auto *iter = registers.begin();
     auto *iterEnd = iter + registers.size() - 1;
@@ -151,7 +151,7 @@ void RangeRegAllocator::Run(IRNode *ins, VReg rangeStart, size_t argCount)
 
     PushBack(ins);
 
-    while (spillIndex_ != 0) {
+    while (spill_index_ != 0) {
         Restore(ins);
     }
 }
diff --git a/compiler/core/regAllocator.h b/compiler/core/regAllocator.h
index da5eeffecfb7646ce4fdbc314bf26d6dddc792a6..e187ab255c690f56fdc01757eaed9a54378ff6f6 100644
--- a/compiler/core/regAllocator.h
+++ b/compiler/core/regAllocator.h
@@ -121,8 +121,8 @@ protected:
     VReg Spill(IRNode *ins, VReg reg);
     void Restore(IRNode *ins);
 
-    VReg spillIndex_ {0};
-    VReg regEnd_ {0};
+    VReg spill_index_ {0};
+    VReg reg_end_ {0};
     size_t limit_ {0};
 };
 
diff --git a/compiler/core/regScope.cpp b/compiler/core/regScope.cpp
index 588340ed6b4b47818e86663c4e2567f64498c294..44f006c384fa5ef25bb4c2cf9d59584838f10b76 100644
--- a/compiler/core/regScope.cpp
+++ b/compiler/core/regScope.cpp
@@ -27,12 +27,12 @@ namespace panda::es2panda::compiler {
 
 // RegScope
 
-RegScope::RegScope(PandaGen *pg) : pg_(pg), regBase_(pg_->usedRegs_) {}
+RegScope::RegScope(PandaGen *pg) : pg_(pg), reg_base_(pg_->used_regs_) {}
 
 RegScope::~RegScope()
 {
-    pg_->totalRegs_ = std::max(pg_->totalRegs_, pg_->usedRegs_);
-    pg_->usedRegs_ = regBase_;
+    pg_->total_regs_ = std::max(pg_->total_regs_, pg_->used_regs_);
+    pg_->used_regs_ = reg_base_;
 }
 
 void RegScope::DebuggerCloseScope()
@@ -50,7 +50,7 @@ LocalRegScope::LocalRegScope(PandaGen *pg) : RegScope(pg) {}
 
 LocalRegScope::LocalRegScope(PandaGen *pg, binder::Scope *scope) : RegScope(pg)
 {
-    prevScope_ = pg_->scope_;
+    prev_scope_ = pg_->scope_;
     pg_->scope_ = scope;
 
     for (const auto &[_, var] : scope->Bindings()) {
@@ -62,7 +62,7 @@ LocalRegScope::LocalRegScope(PandaGen *pg, binder::Scope *scope) : RegScope(pg)
 
     if (pg_->IsDebug()) {
         pg_->scope_->SetScopeStart(pg_->insns_.back());
-        pg_->debugInfo_.variableDebugInfo.push_back(pg_->scope_);
+        pg_->debug_info_.variable_debug_info_.push_back(pg_->scope_);
     }
 
     Hoisting::Hoist(pg_);
@@ -70,18 +70,18 @@ LocalRegScope::LocalRegScope(PandaGen *pg, binder::Scope *scope) : RegScope(pg)
 
 LocalRegScope::~LocalRegScope()
 {
-    if (!prevScope_) {
+    if (!prev_scope_) {
         return;
     }
 
     DebuggerCloseScope();
 
-    pg_->scope_ = prevScope_;
+    pg_->scope_ = prev_scope_;
 }
 
 // FunctionRegScope
 
-FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), envScope_(pg->Allocator()->New<EnvScope>())
+FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), env_scope_(pg->Allocator()->New<EnvScope>())
 {
     ASSERT(pg_->Scope()->IsFunctionVariableScope());
     ASSERT(pg_->NextReg() == binder::Binder::MANDATORY_PARAM_FUNC_REG);
@@ -95,7 +95,7 @@ FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), envScope_(pg->A
         }
     }
 
-    envScope_->Initialize(pg_, pg->AllocReg());
+    env_scope_->Initialize(pg_, pg->AllocReg());
 
     for (const auto &[_, var] : funcScope->Bindings()) {
         (void)_;
@@ -109,10 +109,10 @@ FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), envScope_(pg->A
     }
 
     if (pg_->IsDebug()) {
-        pg_->debugInfo_.variableDebugInfo.push_back(funcScope);
+        pg_->debug_info_.variable_debug_info_.push_back(funcScope);
     }
 
-    pg_->LoadAccFromArgs(pg_->rootNode_);
+    pg_->LoadAccFromArgs(pg_->root_node_);
 
     if (funcScope->IsModuleScope()) {
         ModuleContext::Compile(pg_, pg_->scope_->AsModuleScope());
@@ -124,12 +124,12 @@ FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), envScope_(pg->A
 FunctionRegScope::~FunctionRegScope()
 {
     if (pg_->IsDebug()) {
-        pg_->topScope_->SetScopeStart(pg_->insns_.front());
+        pg_->top_scope_->SetScopeStart(pg_->insns_.front());
     }
 
     DebuggerCloseScope();
 
-    envScope_->~EnvScope();
+    env_scope_->~EnvScope();
 }
 
 }  // namespace panda::es2panda::compiler
diff --git a/compiler/core/regScope.h b/compiler/core/regScope.h
index a34029c4f04ae87af4ab2267e52e3a5109a5196f..b0b71a6eeab39f25c92920946ba16f8ed9af87c0 100644
--- a/compiler/core/regScope.h
+++ b/compiler/core/regScope.h
@@ -42,7 +42,7 @@ protected:
     void DebuggerCloseScope();
 
     PandaGen *pg_;
-    uint32_t regBase_;
+    uint32_t reg_base_;
 };
 
 class LocalRegScope : public RegScope {
@@ -57,7 +57,7 @@ public:
     void *operator new[](size_t) = delete;
 
 private:
-    binder::Scope *prevScope_ {};
+    binder::Scope *prev_scope_ {};
 };
 
 class LoopRegScope : public RegScope {
@@ -71,7 +71,7 @@ public:
     void *operator new[](size_t) = delete;
 
 private:
-    binder::Scope *prevScope_ {};
+    binder::Scope *prev_scope_ {};
 };
 
 class FunctionRegScope : public RegScope {
@@ -85,7 +85,7 @@ public:
     void *operator new[](size_t) = delete;
 
 private:
-    EnvScope *envScope_;
+    EnvScope *env_scope_;
 };
 
 }  // namespace panda::es2panda::compiler
diff --git a/compiler/core/switchBuilder.cpp b/compiler/core/switchBuilder.cpp
index 6dfa51d8fbc4d16f4ca50fca8765fa69f6d97a32..d17bfb783437285442ab1b6f071d5ff40697e41d 100644
--- a/compiler/core/switchBuilder.cpp
+++ b/compiler/core/switchBuilder.cpp
@@ -26,10 +26,10 @@ namespace panda::es2panda::compiler {
 // SwitchBuilder
 
 SwitchBuilder::SwitchBuilder(PandaGen *pg, const ir::SwitchStatement *stmt)
-    : pg_(pg), end_(pg->AllocLabel()), labelCtx_(pg, LabelTarget(end_, LabelTarget::BREAK_LABEL)), stmt_(stmt)
+    : pg_(pg), end_(pg->AllocLabel()), label_ctx_(pg, LabelTarget(end_, LabelTarget::BREAK_LABEL)), stmt_(stmt)
 {
     for (size_t i = 0; i < stmt_->Cases().size(); i++) {
-        caseLabels_.push_back(pg_->AllocLabel());
+        case_labels_.push_back(pg_->AllocLabel());
     }
 }
 
@@ -40,7 +40,7 @@ SwitchBuilder::~SwitchBuilder()
 
 void SwitchBuilder::SetCaseTarget(uint32_t index)
 {
-    pg_->SetLabel(stmt_->Cases()[index], caseLabels_[index]);
+    pg_->SetLabel(stmt_->Cases()[index], case_labels_[index]);
 }
 
 void SwitchBuilder::CompileTagOfSwitch(VReg tag)
@@ -60,13 +60,13 @@ void SwitchBuilder::JumpIfCase(VReg tag, uint32_t index)
 {
     const ir::SwitchCaseStatement *caseTarget = stmt_->Cases()[index];
     caseTarget->Test()->Compile(pg_);
-    pg_->Condition(caseTarget, lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL, tag, caseLabels_[index]);
+    pg_->Condition(caseTarget, lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL, tag, case_labels_[index]);
 }
 
 void SwitchBuilder::JumpToDefault(uint32_t defaultIndex)
 {
     const ir::SwitchCaseStatement *defaultTarget = stmt_->Cases()[defaultIndex];
-    pg_->Branch(defaultTarget, caseLabels_[defaultIndex]);
+    pg_->Branch(defaultTarget, case_labels_[defaultIndex]);
 }
 
 void SwitchBuilder::Break()
diff --git a/compiler/core/switchBuilder.h b/compiler/core/switchBuilder.h
index cea6db1b5dcb6be513c89fcb5f980ef38fff8a89..ad7f6bce28cc7287ec9acee91503528877fcd5a6 100644
--- a/compiler/core/switchBuilder.h
+++ b/compiler/core/switchBuilder.h
@@ -44,9 +44,9 @@ public:
 private:
     PandaGen *pg_;
     Label *end_;
-    LabelContext labelCtx_;
+    LabelContext label_ctx_;
     const ir::SwitchStatement *stmt_;
-    std::vector<Label *> caseLabels_;
+    std::vector<Label *> case_labels_;
 };
 }  // namespace panda::es2panda::compiler
 
diff --git a/compiler/debugger/debuginfoDumper.cpp b/compiler/debugger/debuginfoDumper.cpp
index 24f9745a6173d477238535bf867bd98eeeaf9610..f3ecbfa31a65d171916c8f01e7f402362fd4c703 100644
--- a/compiler/debugger/debuginfoDumper.cpp
+++ b/compiler/debugger/debuginfoDumper.cpp
@@ -64,7 +64,7 @@ void DebugInfoDumper::WrapArray(const char *name, const std::vector<T> &array, b
                 WriteIns(*elem);
                 // NOLINTNEXTLINE
             } else if constexpr (std::is_same_v<T, pandasm::Function::Parameter>) {
-                ss_ << "\"" << (*elem).type.GetName() << "\"";
+                ss_ << "\"" << (*elem).type_.GetName() << "\"";
                 // NOLINTNEXTLINE
             } else if constexpr (std::is_same_v<T, std::string>) {
                 ss_ << "\"" << *elem << "\"";
@@ -96,20 +96,20 @@ void DebugInfoDumper::WriteIns(const pandasm::Ins &ins)
     ss_ << "{";
     {
         pandasm::Ins insCopy;
-        insCopy.opcode = ins.opcode;
-        insCopy.set_label = ins.set_label;
-        insCopy.label = ins.label;
+        insCopy.opcode_ = ins.opcode_;
+        insCopy.set_label_ = ins.set_label_;
+        insCopy.label_ = ins.label_;
         WriteProperty("opcode", insCopy.ToString());
     }
     indent_++;
-    WrapArray("regs", ins.regs);
-    WrapArray("ids", ins.ids);
-    WrapArray("imms", ins.imms);
+    WrapArray("regs", ins.regs_);
+    WrapArray("ids", ins.ids_);
+    WrapArray("imms", ins.imms_);
     ss_ << std::endl;
     Indent();
     ss_ << "\"label\": "
-        << "\"" << ins.label << "\",";
-    WritePosInfo(ins.ins_debug);
+        << "\"" << ins.label_ << "\",";
+    WritePosInfo(ins.ins_debug_);
     indent_--;
     Indent();
     ss_ << "}";
@@ -134,10 +134,10 @@ void DebugInfoDumper::WritePosInfo(const pandasm::debuginfo::Ins &posInfo)
     ss_ << std::endl;
     Indent();
     ss_ << "\"debug_pos_info\": {";
-    WriteProperty("boundLeft", posInfo.bound_left);
-    WriteProperty("boundRight", posInfo.bound_right);
-    WriteProperty("sourecLineNum", static_cast<int32_t>(posInfo.line_number));
-    WriteProperty("wholeLine", posInfo.whole_line, false);
+    WriteProperty("boundLeft", posInfo.bound_left_);
+    WriteProperty("boundRight", posInfo.bound_right_);
+    WriteProperty("sourecLineNum", static_cast<int32_t>(posInfo.line_number_));
+    WriteProperty("wholeLine", posInfo.whole_line_, false);
     Indent();
     ss_ << "}" << std::endl;
 }
@@ -145,12 +145,12 @@ void DebugInfoDumper::WritePosInfo(const pandasm::debuginfo::Ins &posInfo)
 void DebugInfoDumper::WriteVariableInfo(const pandasm::debuginfo::LocalVariable &localVariableDebug)
 {
     ss_ << "{";
-    WriteProperty("name", localVariableDebug.name);
-    WriteProperty("signature", localVariableDebug.signature);
-    WriteProperty("signatureType", localVariableDebug.signature_type);
-    WriteProperty("reg", localVariableDebug.reg);
-    WriteProperty("start", static_cast<size_t>(localVariableDebug.start));
-    WriteProperty("length", static_cast<size_t>(localVariableDebug.length), false);
+    WriteProperty("name", localVariableDebug.name_);
+    WriteProperty("signature", localVariableDebug.signature_);
+    WriteProperty("signatureType", localVariableDebug.signature_type_);
+    WriteProperty("reg", localVariableDebug.reg_);
+    WriteProperty("start", static_cast<size_t>(localVariableDebug.start_));
+    WriteProperty("length", static_cast<size_t>(localVariableDebug.length_), false);
     Indent();
     ss_ << "}";
 }
@@ -162,9 +162,9 @@ void DebugInfoDumper::Dump()
     Indent();
     ss_ << "\"functions\": [" << std::endl;
 
-    auto iter = prog_->function_table.begin();
+    auto iter = prog_->function_table_.begin();
 
-    for (; iter != prog_->function_table.end(); ++iter) {
+    for (; iter != prog_->function_table_.end(); ++iter) {
         indent_++;
         Indent();
         ss_ << "{";
@@ -174,26 +174,26 @@ void DebugInfoDumper::Dump()
         indent_++;
         Indent();
         ss_ << "\"signature\": {";
-        WriteProperty("retType", iter->second.return_type.GetName());
+        WriteProperty("retType", iter->second.return_type_.GetName());
         indent_++;
-        WrapArray("params", iter->second.params, false);
+        WrapArray("params", iter->second.params_, false);
         indent_ -= 2U;
         ss_ << std::endl;
         Indent();
         ss_ << "},";
 
-        WrapArray("ins", iter->second.ins);
-        WrapArray("variables", iter->second.local_variable_debug);
-        WriteProperty("sourceFile", iter->second.source_file);
-        WriteProperty("sourceCode", iter->second.source_code);
+        WrapArray("ins", iter->second.ins_);
+        WrapArray("variables", iter->second.local_variable_debug_);
+        WriteProperty("sourceFile", iter->second.source_file_);
+        WriteProperty("sourceCode", iter->second.source_code_);
         // icSize - parameterLength - funcName
-        WriteMetaData(iter->second.metadata->GetAnnotations());
+        WriteMetaData(iter->second.metadata_->GetAnnotations());
 
         indent_--;
         Indent();
         ss_ << "}";
 
-        if (std::next(iter) != prog_->function_table.end()) {
+        if (std::next(iter) != prog_->function_table_.end()) {
             ss_ << ",";
         }
 
diff --git a/compiler/function/asyncFunctionBuilder.cpp b/compiler/function/asyncFunctionBuilder.cpp
index acbbc790ab449ea78e45f907ad6cc3d527c0c3d5..f097a6a31f03a6706f527a29f19b57c340e88847 100644
--- a/compiler/function/asyncFunctionBuilder.cpp
+++ b/compiler/function/asyncFunctionBuilder.cpp
@@ -23,7 +23,7 @@ namespace panda::es2panda::compiler {
 
 void AsyncFunctionBuilder::DirectReturn(const ir::AstNode *node) const
 {
-    pg_->AsyncFunctionResolve(node, funcObj_);
+    pg_->AsyncFunctionResolve(node, func_obj_);
     pg_->EmitReturn(node);
 }
 
@@ -36,17 +36,17 @@ void AsyncFunctionBuilder::ImplicitReturn(const ir::AstNode *node) const
 void AsyncFunctionBuilder::Prepare(const ir::ScriptFunction *node) const
 {
     pg_->AsyncFunctionEnter(node);
-    pg_->StoreAccumulator(node, funcObj_);
-    pg_->SetLabel(node, catchTable_->LabelSet().TryBegin());
+    pg_->StoreAccumulator(node, func_obj_);
+    pg_->SetLabel(node, catch_table_->LabelSet().TryBegin());
 }
 
 void AsyncFunctionBuilder::CleanUp(const ir::ScriptFunction *node) const
 {
-    const auto &labelSet = catchTable_->LabelSet();
+    const auto &labelSet = catch_table_->LabelSet();
 
     pg_->SetLabel(node, labelSet.TryEnd());
     pg_->SetLabel(node, labelSet.CatchBegin());
-    pg_->AsyncFunctionReject(node, funcObj_);
+    pg_->AsyncFunctionReject(node, func_obj_);
     pg_->EmitReturn(node);
     pg_->SetLabel(node, labelSet.CatchEnd());
 }
diff --git a/compiler/function/asyncGeneratorFunctionBuilder.cpp b/compiler/function/asyncGeneratorFunctionBuilder.cpp
index c4360cd87af39409aa8692c5872f7498320848e7..415c77c8a98ab0e9242be920d93da013611cabab 100644
--- a/compiler/function/asyncGeneratorFunctionBuilder.cpp
+++ b/compiler/function/asyncGeneratorFunctionBuilder.cpp
@@ -25,25 +25,25 @@ void AsyncGeneratorFunctionBuilder::Prepare(const ir::ScriptFunction *node) cons
     VReg callee = FunctionReg(node);
 
     pg_->CreateAsyncGeneratorObj(node, callee);
-    pg_->StoreAccumulator(node, funcObj_);
-    pg_->SuspendGenerator(node, funcObj_);
-    pg_->SetLabel(node, catchTable_->LabelSet().TryBegin());
+    pg_->StoreAccumulator(node, func_obj_);
+    pg_->SuspendGenerator(node, func_obj_);
+    pg_->SetLabel(node, catch_table_->LabelSet().TryBegin());
 }
 
 void AsyncGeneratorFunctionBuilder::CleanUp(const ir::ScriptFunction *node) const
 {
-    const auto &labelSet = catchTable_->LabelSet();
+    const auto &labelSet = catch_table_->LabelSet();
 
     pg_->SetLabel(node, labelSet.TryEnd());
     pg_->SetLabel(node, labelSet.CatchBegin());
-    pg_->AsyncGeneratorReject(node, funcObj_);
+    pg_->AsyncGeneratorReject(node, func_obj_);
     pg_->EmitReturn(node);
     pg_->SetLabel(node, labelSet.CatchEnd());
 }
 
 void AsyncGeneratorFunctionBuilder::DirectReturn(const ir::AstNode *node) const
 {
-    pg_->AsyncGeneratorResolve(node, funcObj_);
+    pg_->AsyncGeneratorResolve(node, func_obj_);
     pg_->EmitReturn(node);
 }
 
@@ -72,7 +72,7 @@ void AsyncGeneratorFunctionBuilder::Yield(const ir::AstNode *node)
     pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, completionType, notReturnCompletion);
     // 27.6.3.8.8.b. Let awaited be Await(resumptionValue.[[Value]]).
     pg_->LoadAccumulator(node, completionValue);
-    pg_->AsyncFunctionAwait(node, funcObj_);
+    pg_->AsyncFunctionAwait(node, func_obj_);
     SuspendResumeExecution(node, completionType, completionValue);
 
     // 27.6.3.8.8.c. If awaited.[[Type]] is throw, return Completion(awaited).
diff --git a/compiler/function/functionBuilder.cpp b/compiler/function/functionBuilder.cpp
index eaba22a71aaada4722e54db98adba4d474341bc6..a5fc9325b637a658fb762629e397d96032329adb 100644
--- a/compiler/function/functionBuilder.cpp
+++ b/compiler/function/functionBuilder.cpp
@@ -25,7 +25,7 @@
 namespace panda::es2panda::compiler {
 
 FunctionBuilder::FunctionBuilder(PandaGen *pg, CatchTable *catchTable)
-    : pg_(pg), catchTable_(catchTable), funcObj_(pg_->AllocReg())
+    : pg_(pg), catch_table_(catchTable), func_obj_(pg_->AllocReg())
 {
 }
 
@@ -57,8 +57,8 @@ void FunctionBuilder::AsyncYield(const ir::AstNode *node, VReg completionType, V
 {
     ASSERT(BuilderKind() == BuilderType::ASYNC_GENERATOR);
 
-    pg_->GeneratorYield(node, funcObj_);
-    pg_->SuspendAsyncGenerator(node, funcObj_);
+    pg_->GeneratorYield(node, func_obj_);
+    pg_->SuspendAsyncGenerator(node, func_obj_);
 
     resumeGenerator(node, completionType, completionValue);
 }
@@ -68,7 +68,7 @@ void FunctionBuilder::SuspendResumeExecution(const ir::AstNode *node, VReg compl
     ASSERT(BuilderKind() == BuilderType::ASYNC || BuilderKind() == BuilderType::ASYNC_GENERATOR ||
            BuilderKind() == BuilderType::GENERATOR);
 
-    pg_->SuspendGenerator(node, funcObj_);
+    pg_->SuspendGenerator(node, func_obj_);
     resumeGenerator(node, completionType, completionValue);
 }
 
@@ -77,9 +77,9 @@ void FunctionBuilder::resumeGenerator(const ir::AstNode *node, VReg completionTy
     ASSERT(BuilderKind() == BuilderType::ASYNC || BuilderKind() == BuilderType::ASYNC_GENERATOR ||
            BuilderKind() == BuilderType::GENERATOR);
 
-    pg_->ResumeGenerator(node, funcObj_);
+    pg_->ResumeGenerator(node, func_obj_);
     pg_->StoreAccumulator(node, completionValue);
-    pg_->GetResumeMode(node, funcObj_);
+    pg_->GetResumeMode(node, func_obj_);
     pg_->StoreAccumulator(node, completionType);
 }
 
@@ -87,8 +87,8 @@ VReg FunctionBuilder::FunctionReg(const ir::ScriptFunction *node) const
 {
     binder::FunctionScope *scope = node->Scope();
     auto res = scope->Find(binder::Binder::MANDATORY_PARAM_FUNC);
-    ASSERT(res.level == 0 && res.variable->IsLocalVariable());
-    return res.variable->AsLocalVariable()->Vreg();
+    ASSERT(res.level_ == 0 && res.variable_->IsLocalVariable());
+    return res.variable_->AsLocalVariable()->Vreg();
 }
 
 void FunctionBuilder::Await(const ir::AstNode *node)
@@ -104,7 +104,7 @@ void FunctionBuilder::Await(const ir::AstNode *node)
     VReg completionType = pg_->AllocReg();
     VReg completionValue = pg_->AllocReg();
 
-    pg_->AsyncFunctionAwait(node, funcObj_);
+    pg_->AsyncFunctionAwait(node, func_obj_);
     SuspendResumeExecution(node, completionType, completionValue);
 
     HandleCompletion(node, completionType, completionValue);
@@ -117,10 +117,10 @@ void FunctionBuilder::HandleCompletion(const ir::AstNode *node, VReg completionT
 
     auto *notRetLabel = pg_->AllocLabel();
     pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, completionType, notRetLabel);
-    if (!handleReturn_) {
-        handleReturn_ = true;
+    if (!handle_return_) {
+        handle_return_ = true;
         pg_->ControlFlowChangeBreak();
-        handleReturn_ = false;
+        handle_return_ = false;
     }
 
     pg_->LoadAccumulator(node, completionValue);
@@ -265,7 +265,7 @@ void FunctionBuilder::YieldStar(const ir::AstNode *node)
 
         // b. Let awaited be Await(resumptionValue.[[Value]]).
         pg_->LoadAccumulator(node, receivedValue);
-        pg_->AsyncFunctionAwait(node, funcObj_);
+        pg_->AsyncFunctionAwait(node, func_obj_);
         SuspendResumeExecution(node, receivedType, receivedValue);
 
         // c. If awaited.[[Type]] is throw, return Completion(awaited).
@@ -277,7 +277,7 @@ void FunctionBuilder::YieldStar(const ir::AstNode *node)
         // vii. Else, set received to GeneratorYield(innerResult).
         // 8. Else, set received to GeneratorYield(innerResult).
         // x. Else, set received to GeneratorYield(innerReturnResult).
-        pg_->GeneratorYield(node, funcObj_);
+        pg_->GeneratorYield(node, func_obj_);
         SuspendResumeExecution(node, receivedType, receivedValue);
     }
 
diff --git a/compiler/function/functionBuilder.h b/compiler/function/functionBuilder.h
index 4147c49577a673a71ea7f8ee198bc1e2158443ce..c957d8b537447cd36c38e99c4778523edb8f8bfc 100644
--- a/compiler/function/functionBuilder.h
+++ b/compiler/function/functionBuilder.h
@@ -78,9 +78,9 @@ protected:
     void HandleCompletion(const ir::AstNode *node, VReg completionType, VReg completionValue);
 
     PandaGen *pg_;
-    CatchTable *catchTable_;
-    VReg funcObj_ {};
-    bool handleReturn_ {};
+    CatchTable *catch_table_;
+    VReg func_obj_ {};
+    bool handle_return_ {};
 
 private:
     void resumeGenerator(const ir::AstNode *node, VReg completionType, VReg completionValue) const;
diff --git a/compiler/function/generatorFunctionBuilder.cpp b/compiler/function/generatorFunctionBuilder.cpp
index a4d71b3fd2dac50aded1c33cabc31d89dac78a15..ae7e5ed004ea9b86c78fd231ef8c9167ca1841b0 100644
--- a/compiler/function/generatorFunctionBuilder.cpp
+++ b/compiler/function/generatorFunctionBuilder.cpp
@@ -26,25 +26,25 @@ void GeneratorFunctionBuilder::Prepare(const ir::ScriptFunction *node) const
     VReg callee = FunctionReg(node);
 
     pg_->CreateGeneratorObj(node, callee);
-    pg_->StoreAccumulator(node, funcObj_);
-    pg_->SuspendGenerator(node, funcObj_);
-    pg_->SetLabel(node, catchTable_->LabelSet().TryBegin());
+    pg_->StoreAccumulator(node, func_obj_);
+    pg_->SuspendGenerator(node, func_obj_);
+    pg_->SetLabel(node, catch_table_->LabelSet().TryBegin());
 }
 
 void GeneratorFunctionBuilder::CleanUp(const ir::ScriptFunction *node) const
 {
-    const auto &labelSet = catchTable_->LabelSet();
+    const auto &labelSet = catch_table_->LabelSet();
 
     pg_->SetLabel(node, labelSet.TryEnd());
     pg_->SetLabel(node, labelSet.CatchBegin());
-    pg_->GeneratorComplete(node, funcObj_);
+    pg_->GeneratorComplete(node, func_obj_);
     pg_->EmitThrow(node);
     pg_->SetLabel(node, labelSet.CatchEnd());
 }
 
 void GeneratorFunctionBuilder::DirectReturn(const ir::AstNode *node) const
 {
-    pg_->GeneratorComplete(node, funcObj_);
+    pg_->GeneratorComplete(node, func_obj_);
     pg_->CreateIterResultObject(node, true);
     pg_->EmitReturn(node);
 }
@@ -62,7 +62,7 @@ void GeneratorFunctionBuilder::Yield(const ir::AstNode *node)
     VReg completionValue = pg_->AllocReg();
 
     pg_->CreateIterResultObject(node, false);
-    pg_->GeneratorYield(node, funcObj_);
+    pg_->GeneratorYield(node, func_obj_);
     SuspendResumeExecution(node, completionType, completionValue);
 
     HandleCompletion(node, completionType, completionValue);
diff --git a/compiler/templates/isa.h.erb b/compiler/templates/isa.h.erb
index 49a5d5869c1eb651fd6c158ffd6743636b347afe..709243bf3c1dd10ef406add628ca90db8a14af0d 100644
--- a/compiler/templates/isa.h.erb
+++ b/compiler/templates/isa.h.erb
@@ -59,9 +59,9 @@ public:
 
     void Transform(pandasm::Ins *ins) const override
     {
-        ins->opcode = pandasm::Opcode::INVALID;
-        ins->set_label = true;
-        ins->label = id_;
+        ins->opcode_ = pandasm::Opcode::INVALID;
+        ins->set_label_ = true;
+        ins->label_ = id_;
     }
 
 private:
@@ -196,27 +196,27 @@ public:
     }
 
     void Transform(pandasm::Ins* ins) const override {
-      ins->opcode = pandasm::Opcode::<%= node_kind %>;
+      ins->opcode_ = pandasm::Opcode::<%= node_kind %>;
 % if op_map['reg'].length != 0
-      ins->regs.reserve(<%= op_map['reg'].length %>);
+      ins->regs_.reserve(<%= op_map['reg'].length %>);
 % end
 % if op_map['imm'].length != 0
-      ins->imms.reserve(<%= op_map['imm'].length %>);
+      ins->imms_.reserve(<%= op_map['imm'].length %>);
 % end
 % if op_map['str'].length + op_map['lbl'].length != 0
-      ins->ids.reserve(<%= op_map['str'].length + op_map['lbl'].length %>);
+      ins->ids_.reserve(<%= op_map['str'].length + op_map['lbl'].length %>);
 % end
 % for reg in op_map['reg']
-      ins->regs.emplace_back(<%= reg %>);
+      ins->regs_.emplace_back(<%= reg %>);
 % end
 % for imm in op_map['imm']
-      ins->imms.emplace_back(<%= imm %>);
+      ins->imms_.emplace_back(<%= imm %>);
 % end
 % for str in op_map['str']
-      ins->ids.emplace_back(<%= str %>.Mutf8());
+      ins->ids_.emplace_back(<%= str %>.Mutf8());
 % end
 % for lbl in op_map['lbl']
-      ins->ids.emplace_back(<%= lbl %>->Id());
+      ins->ids_.emplace_back(<%= lbl %>->Id());
 % end
     }
 
diff --git a/es2panda.cpp b/es2panda.cpp
index 7bb412786ee1a9c11bb7555e706728235d66dcf1..3e3f0cff9a36a9613804e7b12a296bd646094132 100644
--- a/es2panda.cpp
+++ b/es2panda.cpp
@@ -45,17 +45,17 @@ Compiler::~Compiler()
 panda::pandasm::Program *Compiler::Compile(const SourceFile &input, const CompilerOptions &options)
 {
     /* TODO(dbatyai): pass string view */
-    std::string fname(input.fileName);
-    std::string src(input.source);
+    std::string fname(input.file_name_);
+    std::string src(input.source_);
 
     try {
-        auto ast = input.isModule ? parser_->ParseModule(fname, src) : parser_->ParseScript(fname, src);
+        auto ast = input.is_module_ ? parser_->ParseModule(fname, src) : parser_->ParseScript(fname, src);
 
-        if (options.dumpAst) {
+        if (options.dump_ast_) {
             std::cout << ast.Dump() << std::endl;
         }
 
-        if (options.parseOnly) {
+        if (options.parse_only_) {
             return nullptr;
         }
 
diff --git a/es2panda.h b/es2panda.h
index f68866c0caa52f0ecbf0a60cb7d8b18f122ddb6b..52459b554533cb213569389ea9cb05720a4b61f7 100644
--- a/es2panda.h
+++ b/es2panda.h
@@ -40,20 +40,20 @@ enum class ScriptExtension {
 };
 
 struct SourceFile {
-    SourceFile(std::string_view fn, std::string_view s) : fileName(fn), source(s) {};
-    SourceFile(std::string_view fn, std::string_view s, bool m) : fileName(fn), source(s), isModule(m) {};
+    SourceFile(std::string_view fn, std::string_view s) : file_name_(fn), source_(s) {};
+    SourceFile(std::string_view fn, std::string_view s, bool m) : file_name_(fn), source_(s), is_module_(m) {};
 
-    std::string_view fileName {};
-    std::string_view source {};
-    bool isModule {false};
+    std::string_view file_name_ {};
+    std::string_view source_ {};
+    bool is_module_ {false};
 };
 
 struct CompilerOptions {
-    bool isDebug {false};
-    bool dumpAst {false};
-    bool dumpAsm {false};
-    bool dumpDebugInfo {false};
-    bool parseOnly {false};
+    bool is_debug_ {false};
+    bool dump_ast_ {false};
+    bool dump_asm_ {false};
+    bool dump_debug_info_ {false};
+    bool parse_only_ {false};
 };
 
 enum class ErrorType {
@@ -100,7 +100,7 @@ public:
 
     int ErrorCode() const noexcept
     {
-        return errorCode_;
+        return error_code_;
     }
 
     const std::string &Message() const noexcept
@@ -123,7 +123,7 @@ private:
     std::string message_;
     size_t line_ {};
     size_t col_ {};
-    int errorCode_ {1};
+    int error_code_ {1};
 };
 
 class Compiler {
diff --git a/ir/astDump.cpp b/ir/astDump.cpp
index fceef8a07d6403e62feb7cf0480780cf407393f2..71e0b61fc52592720f631b29548cfa3efc0b95e9 100644
--- a/ir/astDump.cpp
+++ b/ir/astDump.cpp
@@ -213,10 +213,10 @@ void AstDumper::SerializeLoc(const lexer::SourceRange &loc)
 
     Wrap([this, &loc]() -> void {
         SerializePropKey("start");
-        SerializeSourcePosition(loc.start);
+        SerializeSourcePosition(loc.start_);
         ss_ << ',';
         SerializePropKey("end");
-        SerializeSourcePosition(loc.end);
+        SerializeSourcePosition(loc.end_);
     });
 }
 
@@ -226,10 +226,10 @@ void AstDumper::SerializeSourcePosition(const lexer::SourcePosition &pos)
 
     Wrap([this, &loc]() -> void {
         SerializePropKey("line");
-        SerializeNumber(loc.line);
+        SerializeNumber(loc.line_);
         ss_ << ',';
         SerializePropKey("column");
-        SerializeNumber(loc.col);
+        SerializeNumber(loc.col_);
     });
 }
 
diff --git a/ir/astNode.h b/ir/astNode.h
index 31f55dacba36f5e7825847f95743c43a0a62c784..22854569d39d9d58bbc73d6adccf7729deac9672 100644
--- a/ir/astNode.h
+++ b/ir/astNode.h
@@ -214,22 +214,22 @@ public:
 
     void SetStart(const lexer::SourcePosition &start)
     {
-        range_.start = start;
+        range_.start_ = start;
     }
 
     void SetEnd(const lexer::SourcePosition &end)
     {
-        range_.end = end;
+        range_.end_ = end;
     }
 
     const lexer::SourcePosition &Start() const
     {
-        return range_.start;
+        return range_.start_;
     }
 
     const lexer::SourcePosition &End() const
     {
-        return range_.end;
+        return range_.end_;
     }
 
     const lexer::SourceRange &Range() const
diff --git a/ir/base/classDefinition.cpp b/ir/base/classDefinition.cpp
index bd18a40d3425b32ea918bd40b81e76f83b0d36a3..7cbdbc87f6636c1081ee294f181d9ed894cdf690 100644
--- a/ir/base/classDefinition.cpp
+++ b/ir/base/classDefinition.cpp
@@ -51,16 +51,16 @@ void ClassDefinition::Iterate(const NodeTraverser &cb) const
         cb(ident_);
     }
 
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
-    if (superClass_) {
-        cb(superClass_);
+    if (super_class_) {
+        cb(super_class_);
     }
 
-    if (superTypeParams_) {
-        cb(superTypeParams_);
+    if (super_type_params_) {
+        cb(super_type_params_);
     }
 
     for (auto *it : implements_) {
@@ -73,7 +73,7 @@ void ClassDefinition::Iterate(const NodeTraverser &cb) const
         cb(it);
     }
 
-    for (auto *it : indexSignatures_) {
+    for (auto *it : index_signatures_) {
         cb(it);
     }
 }
@@ -81,21 +81,21 @@ void ClassDefinition::Iterate(const NodeTraverser &cb) const
 void ClassDefinition::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"id", AstDumper::Nullable(ident_)},
-                 {"typeParameters", AstDumper::Optional(typeParams_)},
-                 {"superClass", AstDumper::Nullable(superClass_)},
-                 {"superTypeParameters", AstDumper::Optional(superTypeParams_)},
+                 {"typeParameters", AstDumper::Optional(type_params_)},
+                 {"superClass", AstDumper::Nullable(super_class_)},
+                 {"superTypeParameters", AstDumper::Optional(super_type_params_)},
                  {"implements", implements_},
                  {"constructor", ctor_},
                  {"body", body_},
-                 {"indexSignatures", indexSignatures_}});
+                 {"indexSignatures", index_signatures_}});
 }
 
 compiler::VReg ClassDefinition::CompileHeritageClause(compiler::PandaGen *pg) const
 {
     compiler::VReg baseReg = pg->AllocReg();
 
-    if (superClass_) {
-        superClass_->Compile(pg);
+    if (super_class_) {
+        super_class_->Compile(pg);
     } else {
         pg->LoadConst(this, compiler::Constant::JS_HOLE);
     }
diff --git a/ir/base/classDefinition.h b/ir/base/classDefinition.h
index 32a1e3096cc8a835adcdb871b94d4f438f8d17a3..d850d492e9171ff1dd1876c6a8d1c9d523e4c2ec 100644
--- a/ir/base/classDefinition.h
+++ b/ir/base/classDefinition.h
@@ -53,13 +53,13 @@ public:
         : AstNode(AstNodeType::CLASS_DEFINITION),
           scope_(scope),
           ident_(ident),
-          typeParams_(typeParams),
-          superTypeParams_(superTypeParams),
+          type_params_(typeParams),
+          super_type_params_(superTypeParams),
           implements_(std::move(implements)),
           ctor_(ctor),
-          superClass_(superClass),
+          super_class_(superClass),
           body_(std::move(body)),
-          indexSignatures_(std::move(indexSignatures)),
+          index_signatures_(std::move(indexSignatures)),
           declare_(declare),
           abstract_(abstract)
     {
@@ -77,12 +77,12 @@ public:
 
     Expression *Super()
     {
-        return superClass_;
+        return super_class_;
     }
 
     const Expression *Super() const
     {
-        return superClass_;
+        return super_class_;
     }
 
     bool Declare() const
@@ -126,13 +126,13 @@ private:
 
     binder::LocalScope *scope_;
     Identifier *ident_;
-    TSTypeParameterDeclaration *typeParams_;
-    TSTypeParameterInstantiation *superTypeParams_;
+    TSTypeParameterDeclaration *type_params_;
+    TSTypeParameterInstantiation *super_type_params_;
     ArenaVector<TSClassImplements *> implements_;
     MethodDefinition *ctor_;
-    Expression *superClass_;
+    Expression *super_class_;
     ArenaVector<Statement *> body_;
-    ArenaVector<TSIndexSignature *> indexSignatures_;
+    ArenaVector<TSIndexSignature *> index_signatures_;
     bool declare_;
     bool abstract_;
 };
diff --git a/ir/base/classProperty.cpp b/ir/base/classProperty.cpp
index b39f7f25305c09baacfd0f5477e573439174f463..ca462f525b8846c1c05fb5a374b4c47965d8f51b 100644
--- a/ir/base/classProperty.cpp
+++ b/ir/base/classProperty.cpp
@@ -32,8 +32,8 @@ void ClassProperty::Iterate(const NodeTraverser &cb) const
         cb(value_);
     }
 
-    if (typeAnnotation_) {
-        cb(typeAnnotation_);
+    if (type_annotation_) {
+        cb(type_annotation_);
     }
 
     for (auto *it : decorators_) {
@@ -52,8 +52,8 @@ void ClassProperty::Dump(ir::AstDumper *dumper) const
                  {"readonly", (modifiers_ & ModifierFlags::READONLY) != 0},
                  {"declare", (modifiers_ & ModifierFlags::DECLARE) != 0},
                  {"optional", (modifiers_ & ModifierFlags::OPTIONAL) != 0},
-                 {"computed", isComputed_},
-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
+                 {"computed", is_computed_},
+                 {"typeAnnotation", AstDumper::Optional(type_annotation_)},
                  {"definite", AstDumper::Optional(definite_)},
                  {"decorators", decorators_}});
 }
diff --git a/ir/base/classProperty.h b/ir/base/classProperty.h
index e1bc499436164b6c94607e0cbc42c6925917c496..17523a6618f09d02be78447673a29d77e43cb440 100644
--- a/ir/base/classProperty.h
+++ b/ir/base/classProperty.h
@@ -38,10 +38,10 @@ public:
         : Statement(AstNodeType::CLASS_PROPERTY),
           key_(key),
           value_(value),
-          typeAnnotation_(typeAnnotation),
+          type_annotation_(typeAnnotation),
           modifiers_(modifiers),
           decorators_(std::move(decorators)),
-          isComputed_(isComputed),
+          is_computed_(isComputed),
           definite_(definite)
     {
     }
@@ -58,7 +58,7 @@ public:
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     ModifierFlags Modifiers() const
@@ -73,7 +73,7 @@ public:
 
     bool IsComputed() const
     {
-        return isComputed_;
+        return is_computed_;
     }
 
     bool Definite() const
@@ -89,10 +89,10 @@ public:
 private:
     Expression *key_;
     Expression *value_;
-    Expression *typeAnnotation_;
+    Expression *type_annotation_;
     ModifierFlags modifiers_;
     ArenaVector<Decorator *> decorators_;
-    bool isComputed_;
+    bool is_computed_;
     bool definite_;
 };
 
diff --git a/ir/base/methodDefinition.cpp b/ir/base/methodDefinition.cpp
index a3798ecfba36c1c9dff5df9a485bc50d06a7e7ce..2f4b1a717db0643f0948520481ac9f98e5ba79e3 100644
--- a/ir/base/methodDefinition.cpp
+++ b/ir/base/methodDefinition.cpp
@@ -76,7 +76,7 @@ void MethodDefinition::Dump(ir::AstDumper *dumper) const
                  {"accessibility", AstDumper::Optional(AstDumper::ModifierToString(modifiers_))},
                  {"static", (modifiers_ & ModifierFlags::STATIC) != 0},
                  {"optional", (modifiers_ & ModifierFlags::OPTIONAL) != 0},
-                 {"computed", isComputed_},
+                 {"computed", is_computed_},
                  {"value", value_},
                  {"overloads", overloads_},
                  {"decorators", decorators_}});
diff --git a/ir/base/methodDefinition.h b/ir/base/methodDefinition.h
index e304cd084e23e350d8457da1bb9b7e676f6fc26b..73252f5b5812bce36b46c3f4de12e510384839fa 100644
--- a/ir/base/methodDefinition.h
+++ b/ir/base/methodDefinition.h
@@ -46,7 +46,7 @@ public:
           modifiers_(modifiers),
           overloads_(allocator->Adapter()),
           decorators_(std::move(decorators)),
-          isComputed_(isComputed)
+          is_computed_(isComputed)
     {
     }
 
@@ -72,7 +72,7 @@ public:
 
     bool Computed() const
     {
-        return isComputed_;
+        return is_computed_;
     }
 
     bool IsStatic() const
@@ -119,7 +119,7 @@ private:
     ModifierFlags modifiers_;
     ArenaVector<MethodDefinition *> overloads_;
     ArenaVector<Decorator *> decorators_;
-    bool isComputed_;
+    bool is_computed_;
 };
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/base/property.cpp b/ir/base/property.cpp
index 5802e381fac4a8a7ee44c1c8616d7938ee2003db..51b3ddf7ab9d421cfd902d34e65d2b13ef291e2d 100644
--- a/ir/base/property.cpp
+++ b/ir/base/property.cpp
@@ -29,7 +29,7 @@ namespace panda::es2panda::ir {
 bool Property::ConventibleToPatternProperty()
 {
     // Object pattern can't contain getter or setter
-    if (IsAccessor() || isMethod_) {
+    if (IsAccessor() || is_method_) {
         return false;
     }
 
@@ -120,9 +120,9 @@ void Property::Dump(ir::AstDumper *dumper) const
     }
 
     dumper->Add({{"type", "Property"},
-                 {"method", isMethod_},
-                 {"shorthand", isShorthand_},
-                 {"computed", isComputed_},
+                 {"method", is_method_},
+                 {"shorthand", is_shorthand_},
+                 {"computed", is_computed_},
                  {"key", key_},
                  {"value", value_},
                  {"kind", kind}});
diff --git a/ir/base/property.h b/ir/base/property.h
index f47df4b114e986183563d4bd394789c7eda03a9d..a0b6ec8b0920ed5be279e476c051f40d95695848 100644
--- a/ir/base/property.h
+++ b/ir/base/property.h
@@ -39,9 +39,9 @@ public:
           kind_(PropertyKind::INIT),
           key_(key),
           value_(value),
-          isMethod_(false),
-          isShorthand_(true),
-          isComputed_(false)
+          is_method_(false),
+          is_shorthand_(true),
+          is_computed_(false)
     {
     }
 
@@ -50,9 +50,9 @@ public:
           kind_(kind),
           key_(key),
           value_(value),
-          isMethod_(isMethod),
-          isShorthand_(false),
-          isComputed_(isComputed)
+          is_method_(isMethod),
+          is_shorthand_(false),
+          is_computed_(isComputed)
     {
     }
 
@@ -83,17 +83,17 @@ public:
 
     bool IsMethod() const
     {
-        return isMethod_;
+        return is_method_;
     }
 
     bool IsShorthand() const
     {
-        return isShorthand_;
+        return is_shorthand_;
     }
 
     bool IsComputed() const
     {
-        return isComputed_;
+        return is_computed_;
     }
 
     bool IsAccessor() const
@@ -117,9 +117,9 @@ private:
     PropertyKind kind_;
     Expression *key_;
     Expression *value_;
-    bool isMethod_;
-    bool isShorthand_;
-    bool isComputed_;
+    bool is_method_;
+    bool is_shorthand_;
+    bool is_computed_;
 };
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/base/scriptFunction.cpp b/ir/base/scriptFunction.cpp
index d4d06783480d148f97ac08d55b34c18ca0326fb6..63f92adf1c708f4e12c5fd81d376134c88722236 100644
--- a/ir/base/scriptFunction.cpp
+++ b/ir/base/scriptFunction.cpp
@@ -46,8 +46,8 @@ void ScriptFunction::Iterate(const NodeTraverser &cb) const
         cb(id_);
     }
 
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
     for (auto *it : params_) {
@@ -67,8 +67,8 @@ void ScriptFunction::Dump(ir::AstDumper *dumper) const
                  {"async", IsAsync()},
                  {"expression", ((flags_ & ir::ScriptFunctionFlags::EXPRESSION) != 0)},
                  {"params", params_},
-                 {"returnType", AstDumper::Optional(returnTypeAnnotation_)},
-                 {"typeParameters", AstDumper::Optional(typeParams_)},
+                 {"returnType", AstDumper::Optional(return_type_annotation_)},
+                 {"typeParameters", AstDumper::Optional(type_params_)},
                  {"declare", AstDumper::Optional(declare_)},
                  {"body", AstDumper::Optional(body_)}});
 }
diff --git a/ir/base/scriptFunction.h b/ir/base/scriptFunction.h
index 3e3a35ed94b630cf718840c0b840a5645e111ea6..59bf362cf9a1393a72829ff235056905eae40a73 100644
--- a/ir/base/scriptFunction.h
+++ b/ir/base/scriptFunction.h
@@ -44,9 +44,9 @@ public:
         : AstNode(AstNodeType::SCRIPT_FUNCTION),
           scope_(scope),
           params_(std::move(params)),
-          typeParams_(typeParams),
+          type_params_(typeParams),
           body_(body),
-          returnTypeAnnotation_(returnTypeAnnotation),
+          return_type_annotation_(returnTypeAnnotation),
           flags_(flags),
           declare_(declare)
     {
@@ -74,7 +74,7 @@ public:
 
     const TSTypeParameterDeclaration *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     const AstNode *Body() const
@@ -89,7 +89,7 @@ public:
 
     const Expression *ReturnTypeAnnotation() const
     {
-        return returnTypeAnnotation_;
+        return return_type_annotation_;
     }
 
     bool IsGenerator() const
@@ -153,9 +153,9 @@ private:
     binder::FunctionScope *scope_;
     Identifier *id_ {nullptr};
     ArenaVector<Expression *> params_;
-    TSTypeParameterDeclaration *typeParams_;
+    TSTypeParameterDeclaration *type_params_;
     AstNode *body_;
-    Expression *returnTypeAnnotation_;
+    Expression *return_type_annotation_;
     ir::ScriptFunctionFlags flags_;
     bool declare_;
 };
diff --git a/ir/base/spreadElement.cpp b/ir/base/spreadElement.cpp
index fec7ceadd1df2f5c1dc0541dc8ec76d8f9b8ab75..fac5a5e8dbf25b293f3b351751eafbe794def11b 100644
--- a/ir/base/spreadElement.cpp
+++ b/ir/base/spreadElement.cpp
@@ -76,15 +76,15 @@ bool SpreadElement::ConvertibleToRest(bool isDeclaration, bool allowPattern)
 
 void SpreadElement::SetTsTypeAnnotation(Expression *typeAnnotation)
 {
-    typeAnnotation_ = typeAnnotation;
+    type_annotation_ = typeAnnotation;
 }
 
 void SpreadElement::Iterate(const NodeTraverser &cb) const
 {
     cb(argument_);
 
-    if (typeAnnotation_) {
-        cb(typeAnnotation_);
+    if (type_annotation_) {
+        cb(type_annotation_);
     }
 }
 
@@ -92,7 +92,7 @@ void SpreadElement::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", (type_ == AstNodeType::SPREAD_ELEMENT) ? "SpreadElement" : "RestElement"},
                  {"argument", argument_},
-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)}});
+                 {"typeAnnotation", AstDumper::Optional(type_annotation_)}});
 }
 
 void SpreadElement::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/base/spreadElement.h b/ir/base/spreadElement.h
index 858ef0122bac8767db0372f25baeffbb3d820c5e..bb2d3531beb775bd1ce0b3e7d7759ea4d6a0c04a 100644
--- a/ir/base/spreadElement.h
+++ b/ir/base/spreadElement.h
@@ -46,7 +46,7 @@ public:
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     ValidationInfo ValidateExpression();
@@ -60,7 +60,7 @@ public:
 
 private:
     Expression *argument_;
-    Expression *typeAnnotation_ {};
+    Expression *type_annotation_ {};
 };
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/expressions/arrayExpression.cpp b/ir/expressions/arrayExpression.cpp
index c2f56bb616224b2b7fc6e0a3c52960952cff0da7..08fd7f3ab5373001c3dcf60e7a0ea4094bcd2932 100644
--- a/ir/expressions/arrayExpression.cpp
+++ b/ir/expressions/arrayExpression.cpp
@@ -37,8 +37,8 @@ bool ArrayExpression::ConvertibleToArrayPattern()
                 break;
             }
             case AstNodeType::SPREAD_ELEMENT: {
-                if (!restFound && it == elements_.back() && !trailingComma_) {
-                    convResult = it->AsSpreadElement()->ConvertibleToRest(isDeclaration_);
+                if (!restFound && it == elements_.back() && !trailing_comma_) {
+                    convResult = it->AsSpreadElement()->ConvertibleToRest(is_declaration_);
                 } else {
                     convResult = false;
                 }
@@ -121,8 +121,8 @@ void ArrayExpression::Iterate(const NodeTraverser &cb) const
         cb(it);
     }
 
-    if (typeAnnotation_) {
-        cb(typeAnnotation_);
+    if (type_annotation_) {
+        cb(type_annotation_);
     }
 }
 
@@ -130,7 +130,7 @@ void ArrayExpression::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", type_ == AstNodeType::ARRAY_EXPRESSION ? "ArrayExpression" : "ArrayPattern"},
                  {"elements", elements_},
-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
+                 {"typeAnnotation", AstDumper::Optional(type_annotation_)},
                  {"optional", AstDumper::Optional(optional_)}});
 }
 
@@ -260,7 +260,7 @@ checker::Type *ArrayExpression::Check(checker::Checker *checker) const
             memberVar->AddFlag(binder::VariableFlags::PROPERTY);
             memberVar->SetTsType(currentElementType);
             elementFlags.insert({memberIndex, checker::ElementFlags::REQUIRED});
-            desc->properties.push_back(memberVar);
+            desc->properties_.push_back(memberVar);
             index++;
         }
 
@@ -286,7 +286,7 @@ checker::Type *ArrayExpression::Check(checker::Checker *checker) const
 
     if (forceTuple) {
         // TODO(aszilagyi): handle readonly when creating IndexInfo and TupleType
-        desc->numberIndexInfo = checker->Allocator()->New<checker::IndexInfo>(arrayElementType, "x", false);
+        desc->number_index_info_ = checker->Allocator()->New<checker::IndexInfo>(arrayElementType, "x", false);
         return checker->CreateTupleType(desc, std::move(elementFlags), checker::ElementFlags::REQUIRED, index, index,
                                         false);
     }
@@ -346,13 +346,13 @@ checker::Type *ArrayExpression::CheckPattern(checker::Checker *checker) const
 
         memberVar->SetTsType(elementType);
         elementFlags.insert({memberIndex, memberFlag});
-        desc->properties.push_back(memberVar);
+        desc->properties_.push_back(memberVar);
 
         combinedFlags |= memberFlag;
         index++;
     }
 
-    return checker->CreateTupleType(desc, std::move(elementFlags), combinedFlags, minLength, desc->properties.size(),
+    return checker->CreateTupleType(desc, std::move(elementFlags), combinedFlags, minLength, desc->properties_.size(),
                                     false);
 }
 
diff --git a/ir/expressions/arrayExpression.h b/ir/expressions/arrayExpression.h
index 895ba8493a6bd4bf03385739e57ba12dbe4dfd6d..5dbf43471a22dbf898f4b6f90632be8ab02ea8d3 100644
--- a/ir/expressions/arrayExpression.h
+++ b/ir/expressions/arrayExpression.h
@@ -34,7 +34,7 @@ namespace panda::es2panda::ir {
 class ArrayExpression : public Expression {
 public:
     explicit ArrayExpression(AstNodeType nodeType, ArenaVector<Expression *> &&elements, bool trailingComma)
-        : Expression(nodeType), elements_(std::move(elements)), trailingComma_(trailingComma)
+        : Expression(nodeType), elements_(std::move(elements)), trailing_comma_(trailingComma)
     {
     }
 
@@ -45,12 +45,12 @@ public:
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     bool IsDeclaration() const
     {
-        return isDeclaration_;
+        return is_declaration_;
     }
 
     bool Optional() const
@@ -60,7 +60,7 @@ public:
 
     void SetDeclaration()
     {
-        isDeclaration_ = true;
+        is_declaration_ = true;
     }
 
     void SetOptional(bool optional)
@@ -73,7 +73,7 @@ public:
 
     void SetTsTypeAnnotation(Expression *typeAnnotation) override
     {
-        typeAnnotation_ = typeAnnotation;
+        type_annotation_ = typeAnnotation;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -84,9 +84,9 @@ public:
 
 private:
     ArenaVector<Expression *> elements_;
-    Expression *typeAnnotation_ {nullptr};
-    bool isDeclaration_ {};
-    bool trailingComma_;
+    Expression *type_annotation_ {nullptr};
+    bool is_declaration_ {};
+    bool trailing_comma_;
     bool optional_ {false};
 };
 
diff --git a/ir/expressions/arrowFunctionExpression.cpp b/ir/expressions/arrowFunctionExpression.cpp
index 0a3ac1816e785f9613e9e2218dc655ff057c6403..6821c91a1fdd35421a7620d39218339840df3107 100644
--- a/ir/expressions/arrowFunctionExpression.cpp
+++ b/ir/expressions/arrowFunctionExpression.cpp
@@ -54,9 +54,9 @@ checker::Type *ArrowFunctionExpression::Check([[maybe_unused]] checker::Checker
             const util::StringView &varName = varDecl->AsVariableDeclarator()->Id()->AsIdentifier()->Name();
 
             binder::ScopeFindResult result = checker->Scope()->Find(varName);
-            ASSERT(result.variable);
+            ASSERT(result.variable_);
 
-            funcVar = result.variable;
+            funcVar = result.variable_;
         }
     }
 
@@ -73,7 +73,7 @@ checker::Type *ArrowFunctionExpression::Check([[maybe_unused]] checker::Checker
         returnType = funcVar->TsType();
     } else {
         checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
-        desc->callSignatures.push_back(checker->HandleFunctionReturn(func_, signatureInfo, funcVar));
+        desc->call_signatures_.push_back(checker->HandleFunctionReturn(func_, signatureInfo, funcVar));
         returnType = checker->Allocator()->New<checker::FunctionType>(desc);
     }
 
diff --git a/ir/expressions/callExpression.cpp b/ir/expressions/callExpression.cpp
index bebd28a6792c0b2889299d8e1c05299841f3b55c..f02cb7f5276353e69bb40faa387ff5d580327e96 100644
--- a/ir/expressions/callExpression.cpp
+++ b/ir/expressions/callExpression.cpp
@@ -32,8 +32,8 @@ void CallExpression::Iterate(const NodeTraverser &cb) const
 {
     cb(callee_);
 
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
     for (auto *it : arguments_) {
@@ -47,7 +47,7 @@ void CallExpression::Dump(ir::AstDumper *dumper) const
                  {"callee", callee_},
                  {"arguments", arguments_},
                  {"optional", optional_},
-                 {"typeParameters", AstDumper::Optional(typeParams_)}});
+                 {"typeParameters", AstDumper::Optional(type_params_)}});
 }
 
 compiler::VReg CallExpression::CreateSpreadArguments(compiler::PandaGen *pg) const
diff --git a/ir/expressions/callExpression.h b/ir/expressions/callExpression.h
index c49d17f3d3bf36792718544c849a72e90f5a8c79..3415c8ae45c4e035ecf93d96b5eb2f1bb44dd902 100644
--- a/ir/expressions/callExpression.h
+++ b/ir/expressions/callExpression.h
@@ -39,7 +39,7 @@ public:
         : Expression(AstNodeType::CALL_EXPRESSION),
           callee_(callee),
           arguments_(std::move(arguments)),
-          typeParams_(typeParams),
+          type_params_(typeParams),
           optional_(optional)
     {
     }
@@ -51,7 +51,7 @@ public:
 
     const TSTypeParameterInstantiation *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     const ArenaVector<Expression *> &Arguments() const
@@ -66,7 +66,7 @@ public:
 
     void SetTypeParams(TSTypeParameterInstantiation *typeParams)
     {
-        typeParams_ = typeParams;
+        type_params_ = typeParams;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -79,7 +79,7 @@ private:
 
     Expression *callee_;
     ArenaVector<Expression *> arguments_;
-    TSTypeParameterInstantiation *typeParams_;
+    TSTypeParameterInstantiation *type_params_;
     bool optional_;
 };
 
diff --git a/ir/expressions/functionExpression.cpp b/ir/expressions/functionExpression.cpp
index c8a28b2946e372c30b3111ecca52b89e5ad6ebec..c7d5f885464030b7ded97fed2e56173b7d786d70 100644
--- a/ir/expressions/functionExpression.cpp
+++ b/ir/expressions/functionExpression.cpp
@@ -54,9 +54,9 @@ checker::Type *FunctionExpression::Check(checker::Checker *checker) const
             const util::StringView &varName = varDecl->AsVariableDeclarator()->Id()->AsIdentifier()->Name();
 
             binder::ScopeFindResult result = checker->Scope()->Find(varName);
-            ASSERT(result.variable);
+            ASSERT(result.variable_);
 
-            funcVar = result.variable;
+            funcVar = result.variable_;
         }
     }
 
@@ -72,7 +72,7 @@ checker::Type *FunctionExpression::Check(checker::Checker *checker) const
         returnType = funcVar->TsType();
     } else {
         checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
-        desc->callSignatures.push_back(checker->HandleFunctionReturn(func_, signatureInfo, funcVar));
+        desc->call_signatures_.push_back(checker->HandleFunctionReturn(func_, signatureInfo, funcVar));
         returnType = checker->Allocator()->New<checker::FunctionType>(desc);
     }
 
diff --git a/ir/expressions/identifier.cpp b/ir/expressions/identifier.cpp
index 0132d87cec62dc460508a3a0b7b120f9dd7c0b15..8e2fee7bb7a5e5ae651c11074cffecd95e659bf4 100644
--- a/ir/expressions/identifier.cpp
+++ b/ir/expressions/identifier.cpp
@@ -26,8 +26,8 @@ namespace panda::es2panda::ir {
 
 void Identifier::Iterate(const NodeTraverser &cb) const
 {
-    if (typeAnnotation_) {
-        cb(typeAnnotation_);
+    if (type_annotation_) {
+        cb(type_annotation_);
     }
 
     for (auto *it : decorators_) {
@@ -39,7 +39,7 @@ void Identifier::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "Identifier"},
                  {"name", name_},
-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
+                 {"typeAnnotation", AstDumper::Optional(type_annotation_)},
                  {"optional", AstDumper::Optional(IsOptional())},
                  {"decorators", decorators_}});
 }
@@ -47,7 +47,7 @@ void Identifier::Dump(ir::AstDumper *dumper) const
 void Identifier::Compile(compiler::PandaGen *pg) const
 {
     binder::ScopeFindResult res = pg->Scope()->Find(name_);
-    if (res.variable) {
+    if (res.variable_) {
         pg->LoadVar(this, res);
         return;
     }
diff --git a/ir/expressions/identifier.h b/ir/expressions/identifier.h
index 2cfdf042edaa05909e89191c055afcba1a38fee8..ea7cc53101c4e734db7e184b629a00f4c1fa258c 100644
--- a/ir/expressions/identifier.h
+++ b/ir/expressions/identifier.h
@@ -58,14 +58,14 @@ public:
     explicit Identifier(util::StringView name, Expression *typeAnnotation, ArenaAllocator *allocator)
         : Expression(AstNodeType::IDENTIFIER),
           name_(name),
-          typeAnnotation_(typeAnnotation),
+          type_annotation_(typeAnnotation),
           decorators_(allocator->Adapter())
     {
     }
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     const util::StringView &Name() const
@@ -114,7 +114,7 @@ public:
 
     void SetTsTypeAnnotation(Expression *typeAnnotation) override
     {
-        typeAnnotation_ = typeAnnotation;
+        type_annotation_ = typeAnnotation;
     }
 
     binder::Variable *Variable() const
@@ -134,7 +134,7 @@ public:
 
 private:
     util::StringView name_;
-    Expression *typeAnnotation_ {};
+    Expression *type_annotation_ {};
     IdentifierFlags flags_ {IdentifierFlags::NONE};
     ArenaVector<Decorator *> decorators_;
     binder::Variable *variable_ {nullptr};
diff --git a/ir/expressions/objectExpression.cpp b/ir/expressions/objectExpression.cpp
index bb4e2f62db4a15691492513944b6183cf728bd17..d6bb2bb12cad1705456a9445cee3b12308395f47 100644
--- a/ir/expressions/objectExpression.cpp
+++ b/ir/expressions/objectExpression.cpp
@@ -90,8 +90,8 @@ bool ObjectExpression::ConvertibleToObjectPattern()
                 break;
             }
             case AstNodeType::SPREAD_ELEMENT: {
-                if (!restFound && it == properties_.back() && !trailingComma_) {
-                    convResult = it->AsSpreadElement()->ConvertibleToRest(isDeclaration_, false);
+                if (!restFound && it == properties_.back() && !trailing_comma_) {
+                    convResult = it->AsSpreadElement()->ConvertibleToRest(is_declaration_, false);
                 } else {
                     convResult = false;
                 }
@@ -133,7 +133,7 @@ bool ObjectExpression::ConvertibleToObjectPattern()
 
 void ObjectExpression::SetDeclaration()
 {
-    isDeclaration_ = true;
+    is_declaration_ = true;
 }
 
 void ObjectExpression::SetOptional(bool optional)
@@ -143,7 +143,7 @@ void ObjectExpression::SetOptional(bool optional)
 
 void ObjectExpression::SetTsTypeAnnotation(Expression *typeAnnotation)
 {
-    typeAnnotation_ = typeAnnotation;
+    type_annotation_ = typeAnnotation;
 }
 
 void ObjectExpression::Iterate(const NodeTraverser &cb) const
@@ -152,8 +152,8 @@ void ObjectExpression::Iterate(const NodeTraverser &cb) const
         cb(it);
     }
 
-    if (typeAnnotation_) {
-        cb(typeAnnotation_);
+    if (type_annotation_) {
+        cb(type_annotation_);
     }
 }
 
@@ -161,7 +161,7 @@ void ObjectExpression::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", (type_ == AstNodeType::OBJECT_EXPRESSION) ? "ObjectExpression" : "ObjectPattern"},
                  {"properties", properties_},
-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
+                 {"typeAnnotation", AstDumper::Optional(type_annotation_)},
                  {"optional", AstDumper::Optional(optional_)}});
 }
 
@@ -382,8 +382,8 @@ static void CheckPatternProperty(checker::Checker *checker, bool inAssignment, c
         optional = true;
     } else if (inAssignment) {
         binder::ScopeFindResult result = checker->Scope()->Find(propName);
-        if (result.variable) {
-            propType = result.variable->TsType();
+        if (result.variable_) {
+            propType = result.variable_->TsType();
         }
     }
 
@@ -394,7 +394,7 @@ static void CheckPatternProperty(checker::Checker *checker, bool inAssignment, c
     }
 
     newProp->SetTsType(propType);
-    desc->properties.push_back(newProp);
+    desc->properties_.push_back(newProp);
 }
 
 checker::Type *ObjectExpression::CheckPattern(checker::Checker *checker, bool inAssignment) const
@@ -408,7 +408,7 @@ checker::Type *ObjectExpression::CheckPattern(checker::Checker *checker, bool in
             haveRest = true;
             util::StringView indexInfoName("x");
             auto *newIndexInfo = checker->Allocator()->New<checker::IndexInfo>(checker->GlobalAnyType(), indexInfoName);
-            desc->stringIndexInfo = newIndexInfo;
+            desc->string_index_info_ = newIndexInfo;
         } else {
             CheckPatternProperty(checker, inAssignment, desc, it);
         }
@@ -435,25 +435,25 @@ checker::Type *ObjectExpression::Check(checker::Checker *checker) const
         if (it->IsProperty()) {
             checker::ObjectLiteralPropertyInfo propInfo =
                 checker->HandleObjectLiteralProperty(it->AsProperty(), desc, &stringIndexTypes, readonly);
-            if (propInfo.handleNextProp) {
+            if (propInfo.handle_next_prop_) {
                 continue;
             }
 
-            if (desc->FindProperty(propInfo.propName)) {
-                checker->ThrowTypeError({"Duplicate identifier '", propInfo.propName, "'."}, it->Start());
+            if (desc->FindProperty(propInfo.prop_name_)) {
+                checker->ThrowTypeError({"Duplicate identifier '", propInfo.prop_name_, "'."}, it->Start());
             }
 
-            propInfo.propType = checker->GetBaseTypeOfLiteralType(propInfo.propType);
+            propInfo.prop_type_ = checker->GetBaseTypeOfLiteralType(propInfo.prop_type_);
             binder::VariableFlags propFlag =
                 it->AsProperty()->IsMethod() ? binder::VariableFlags::METHOD : binder::VariableFlags::PROPERTY;
-            auto *newProp = binder::Scope::CreateVar(checker->Allocator(), propInfo.propName, propFlag, it);
+            auto *newProp = binder::Scope::CreateVar(checker->Allocator(), propInfo.prop_name_, propFlag, it);
 
-            propInfo.propType->SetVariable(newProp);
-            newProp->SetTsType(propInfo.propType);
+            propInfo.prop_type_->SetVariable(newProp);
+            newProp->SetTsType(propInfo.prop_type_);
             if (readonly) {
-                propInfo.propType->Variable()->AddFlag(binder::VariableFlags::READONLY);
+                propInfo.prop_type_->Variable()->AddFlag(binder::VariableFlags::READONLY);
             }
-            desc->properties.push_back(newProp);
+            desc->properties_.push_back(newProp);
         } else {
             ASSERT(it->IsSpreadElement());
             checker->HandleSpreadElement(it->AsSpreadElement(), desc, it->Start(), readonly);
@@ -464,7 +464,7 @@ checker::Type *ObjectExpression::Check(checker::Checker *checker) const
 
     if (stringIndexType) {
         auto *strIndexInfo = checker->Allocator()->New<checker::IndexInfo>(stringIndexType, "x", readonly);
-        desc->stringIndexInfo = strIndexInfo;
+        desc->string_index_info_ = strIndexInfo;
     }
 
     return checker->Allocator()->New<checker::ObjectLiteralType>(desc);
diff --git a/ir/expressions/objectExpression.h b/ir/expressions/objectExpression.h
index 741db11cd4ea56d50e3d6de3160fdde919ce11fd..8d6735eb23bf437b7f542e01f614a01d162785ca 100644
--- a/ir/expressions/objectExpression.h
+++ b/ir/expressions/objectExpression.h
@@ -39,7 +39,7 @@ namespace panda::es2panda::ir {
 class ObjectExpression : public Expression {
 public:
     explicit ObjectExpression(AstNodeType nodeType, ArenaVector<Expression *> &&properties, bool trailingComma)
-        : Expression(nodeType), properties_(std::move(properties)), trailingComma_(trailingComma)
+        : Expression(nodeType), properties_(std::move(properties)), trailing_comma_(trailingComma)
     {
     }
 
@@ -50,12 +50,12 @@ public:
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     bool IsDeclaration() const
     {
-        return isDeclaration_;
+        return is_declaration_;
     }
 
     bool Optional() const
@@ -81,9 +81,9 @@ private:
     void CompileRemainingProperties(compiler::PandaGen *pg, const util::BitSet *compiled, compiler::VReg objReg) const;
 
     ArenaVector<Expression *> properties_;
-    Expression *typeAnnotation_ {nullptr};
-    bool isDeclaration_ {};
-    bool trailingComma_ {};
+    Expression *type_annotation_ {nullptr};
+    bool is_declaration_ {};
+    bool trailing_comma_ {};
     bool optional_ {false};
 };
 
diff --git a/ir/expressions/taggedTemplateExpression.cpp b/ir/expressions/taggedTemplateExpression.cpp
index 156483238128f3c08159be578dea97e270952b6e..bb2f5aac8787b12ead7fd358355c8a430ff315b4 100644
--- a/ir/expressions/taggedTemplateExpression.cpp
+++ b/ir/expressions/taggedTemplateExpression.cpp
@@ -29,8 +29,8 @@ namespace panda::es2panda::ir {
 
 void TaggedTemplateExpression::Iterate(const NodeTraverser &cb) const
 {
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
     cb(tag_);
@@ -42,7 +42,7 @@ void TaggedTemplateExpression::Dump(ir::AstDumper *dumper) const
     dumper->Add({{"type", "TaggedTemplateExpression"},
                  {"tag", tag_},
                  {"quasi", quasi_},
-                 {"typeParameters", AstDumper::Optional(typeParams_)}});
+                 {"typeParameters", AstDumper::Optional(type_params_)}});
 }
 
 void TaggedTemplateExpression::Compile(compiler::PandaGen *pg) const
diff --git a/ir/expressions/taggedTemplateExpression.h b/ir/expressions/taggedTemplateExpression.h
index 84a4043c8e41a7607be796eb105ad23def590515..f6400b5a24d3f449ecf9bd0b498fc14cb59f121d 100644
--- a/ir/expressions/taggedTemplateExpression.h
+++ b/ir/expressions/taggedTemplateExpression.h
@@ -35,7 +35,7 @@ class TSTypeParameterInstantiation;
 class TaggedTemplateExpression : public Expression {
 public:
     explicit TaggedTemplateExpression(Expression *tag, TemplateLiteral *quasi, TSTypeParameterInstantiation *typeParams)
-        : Expression(AstNodeType::TAGGED_TEMPLATE_EXPRESSION), tag_(tag), quasi_(quasi), typeParams_(typeParams)
+        : Expression(AstNodeType::TAGGED_TEMPLATE_EXPRESSION), tag_(tag), quasi_(quasi), type_params_(typeParams)
     {
     }
 
@@ -51,7 +51,7 @@ public:
 
     const TSTypeParameterInstantiation *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -62,7 +62,7 @@ public:
 protected:
     Expression *tag_;
     TemplateLiteral *quasi_;
-    TSTypeParameterInstantiation *typeParams_;
+    TSTypeParameterInstantiation *type_params_;
 };
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/expressions/thisExpression.cpp b/ir/expressions/thisExpression.cpp
index 920d897cc99f7206a1fae621ec3464ba93bf6140..9aa42afc1d076a855ea41746b134239d828515a3 100644
--- a/ir/expressions/thisExpression.cpp
+++ b/ir/expressions/thisExpression.cpp
@@ -34,7 +34,7 @@ void ThisExpression::Compile(compiler::PandaGen *pg) const
 {
     binder::ScopeFindResult res = pg->Scope()->Find(binder::Binder::MANDATORY_PARAM_THIS);
 
-    ASSERT(res.variable && res.variable->IsLocalVariable());
+    ASSERT(res.variable_ && res.variable_->IsLocalVariable());
     pg->LoadAccFromLexEnv(this, res);
 
     const ir::ScriptFunction *func = util::Helpers::GetContainingConstructor(this);
diff --git a/ir/expressions/unaryExpression.cpp b/ir/expressions/unaryExpression.cpp
index 6e6aaf5b0ac6369d441cd46a46cfa2269c972ed6..3b010382c0f853119b56db6c4cc345ae613ae2ae 100644
--- a/ir/expressions/unaryExpression.cpp
+++ b/ir/expressions/unaryExpression.cpp
@@ -42,7 +42,7 @@ void UnaryExpression::Compile(compiler::PandaGen *pg) const
         case lexer::TokenType::KEYW_DELETE: {
             if (argument_->IsIdentifier()) {
                 binder::ScopeFindResult result = pg->Scope()->Find(argument_->AsIdentifier()->Name());
-                if (!result.variable || (result.scope->IsGlobalScope() && result.variable->IsGlobalVariable())) {
+                if (!result.variable_ || (result.scope_->IsGlobalScope() && result.variable_->IsGlobalVariable())) {
                     compiler::RegScope rs(pg);
                     compiler::VReg variable = pg->AllocReg();
                     compiler::VReg global = pg->AllocReg();
@@ -80,7 +80,7 @@ void UnaryExpression::Compile(compiler::PandaGen *pg) const
                 const ir::Identifier *ident = argument_->AsIdentifier();
 
                 binder::ScopeFindResult res = pg->Scope()->Find(ident->Name());
-                if (!res.variable) {
+                if (!res.variable_) {
                     compiler::RegScope rs(pg);
                     compiler::VReg global = pg->AllocReg();
 
diff --git a/ir/module/exportDefaultDeclaration.h b/ir/module/exportDefaultDeclaration.h
index 997a8e89fb31d7d8fa4f1b9a6813a4f27ddf34c1..236c9b88872a918eb5426675f1e5738a72486d6f 100644
--- a/ir/module/exportDefaultDeclaration.h
+++ b/ir/module/exportDefaultDeclaration.h
@@ -32,7 +32,7 @@ namespace panda::es2panda::ir {
 class ExportDefaultDeclaration : public Statement {
 public:
     explicit ExportDefaultDeclaration(AstNode *decl, bool exportEquals)
-        : Statement(AstNodeType::EXPORT_DEFAULT_DECLARATION), decl_(decl), exportEquals_(exportEquals)
+        : Statement(AstNodeType::EXPORT_DEFAULT_DECLARATION), decl_(decl), export_equals_(exportEquals)
     {
     }
 
@@ -43,7 +43,7 @@ public:
 
     bool IsExportEquals() const
     {
-        return exportEquals_;
+        return export_equals_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -53,7 +53,7 @@ public:
 
 private:
     AstNode *decl_;
-    bool exportEquals_;
+    bool export_equals_;
 };
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/statements/forOfStatement.cpp b/ir/statements/forOfStatement.cpp
index 241a63e7c03751ed8cf2a48707b8c838410b3838..3f397ea78d10daa8bfd0f68eb70ee5000c733287 100644
--- a/ir/statements/forOfStatement.cpp
+++ b/ir/statements/forOfStatement.cpp
@@ -35,7 +35,8 @@ void ForOfStatement::Iterate(const NodeTraverser &cb) const
 
 void ForOfStatement::Dump(ir::AstDumper *dumper) const
 {
-    dumper->Add({{"type", "ForOfStatement"}, {"await", isAwait_}, {"left", left_}, {"right", right_}, {"body", body_}});
+    dumper->Add(
+        {{"type", "ForOfStatement"}, {"await", is_await_}, {"left", left_}, {"right", right_}, {"body", body_}});
 }
 
 void ForOfStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
@@ -45,7 +46,7 @@ void ForOfStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
     right_->Compile(pg);
 
     compiler::LabelTarget labelTarget(pg);
-    auto iterator_type = isAwait_ ? compiler::IteratorType::ASYNC : compiler::IteratorType::SYNC;
+    auto iterator_type = is_await_ ? compiler::IteratorType::ASYNC : compiler::IteratorType::SYNC;
     compiler::Iterator iterator(pg, this, iterator_type);
 
     pg->SetLabel(this, labelTarget.ContinueTarget());
diff --git a/ir/statements/forOfStatement.h b/ir/statements/forOfStatement.h
index c48b5ea9be8c7b05f16995c32ef6f75f0c370575..0ecb752c9fb95e01af4e34085d6b55822ca9bbbc 100644
--- a/ir/statements/forOfStatement.h
+++ b/ir/statements/forOfStatement.h
@@ -42,7 +42,7 @@ public:
           left_(left),
           right_(right),
           body_(body),
-          isAwait_(isAwait)
+          is_await_(isAwait)
     {
     }
 
@@ -78,7 +78,7 @@ public:
 
     bool IsAwait() const
     {
-        return isAwait_;
+        return is_await_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -90,7 +90,7 @@ private:
     AstNode *left_;
     Expression *right_;
     Statement *body_;
-    bool isAwait_;
+    bool is_await_;
 };
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/statements/functionDeclaration.cpp b/ir/statements/functionDeclaration.cpp
index e07fe784ab2e4eaebd2d8525a3122ad13a82e90e..2fad345107e3cfadc205950891115b7d8e910eef 100644
--- a/ir/statements/functionDeclaration.cpp
+++ b/ir/statements/functionDeclaration.cpp
@@ -46,10 +46,10 @@ checker::Type *FunctionDeclaration::Check([[maybe_unused]] checker::Checker *che
 
     const util::StringView &funcName = func_->Id()->Name();
     binder::ScopeFindResult result = checker->Scope()->Find(funcName);
-    ASSERT(result.variable);
+    ASSERT(result.variable_);
 
-    if (!result.variable->TsType()) {
-        checker->InferFunctionDeclarationType(result.variable->Declaration()->AsFunctionDecl(), result.variable);
+    if (!result.variable_->TsType()) {
+        checker->InferFunctionDeclarationType(result.variable_->Declaration()->AsFunctionDecl(), result.variable_);
     }
 
     func_->Body()->Check(checker);
diff --git a/ir/statements/tryStatement.cpp b/ir/statements/tryStatement.cpp
index b5733e1af3b86c9a58aa338960ea60fb6401e0eb..d51702411f2e74f735a9350648abc59de7746808 100644
--- a/ir/statements/tryStatement.cpp
+++ b/ir/statements/tryStatement.cpp
@@ -28,8 +28,8 @@ void TryStatement::Iterate(const NodeTraverser &cb) const
 {
     cb(block_);
 
-    if (catchClause_) {
-        cb(catchClause_);
+    if (catch_clause_) {
+        cb(catch_clause_);
     }
 
     if (finalizer_) {
@@ -41,7 +41,7 @@ void TryStatement::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TryStatement"},
                  {"block", block_},
-                 {"handler", AstDumper::Nullable(catchClause_)},
+                 {"handler", AstDumper::Nullable(catch_clause_)},
                  {"finalizer", AstDumper::Nullable(finalizer_)}});
 }
 
@@ -72,7 +72,7 @@ void TryStatement::CompileFinally(compiler::PandaGen *pg, compiler::TryContext *
 
 void TryStatement::CompileTryCatchFinally(compiler::PandaGen *pg) const
 {
-    ASSERT(catchClause_ && finalizer_);
+    ASSERT(catch_clause_ && finalizer_);
 
     compiler::TryContext tryCtx(pg, this);
     const auto &labelSet = tryCtx.LabelSet();
@@ -89,7 +89,7 @@ void TryStatement::CompileTryCatchFinally(compiler::PandaGen *pg) const
         pg->Branch(this, innerLabelSet.CatchEnd());
 
         pg->SetLabel(this, innerLabelSet.CatchBegin());
-        catchClause_->Compile(pg);
+        catch_clause_->Compile(pg);
         pg->SetLabel(this, innerLabelSet.CatchEnd());
     }
     pg->SetLabel(this, labelSet.TryEnd());
@@ -99,7 +99,7 @@ void TryStatement::CompileTryCatchFinally(compiler::PandaGen *pg) const
 
 void TryStatement::CompileTryFinally(compiler::PandaGen *pg) const
 {
-    ASSERT(!catchClause_ && finalizer_);
+    ASSERT(!catch_clause_ && finalizer_);
 
     compiler::TryContext tryCtx(pg, this);
     const auto &labelSet = tryCtx.LabelSet();
@@ -126,7 +126,7 @@ void TryStatement::CompileTryFinally(compiler::PandaGen *pg) const
 
 void TryStatement::CompileTryCatch(compiler::PandaGen *pg) const
 {
-    ASSERT(catchClause_ && !finalizer_);
+    ASSERT(catch_clause_ && !finalizer_);
 
     compiler::TryContext tryCtx(pg, this);
     const auto &labelSet = tryCtx.LabelSet();
@@ -138,14 +138,14 @@ void TryStatement::CompileTryCatch(compiler::PandaGen *pg) const
     pg->Branch(this, labelSet.CatchEnd());
 
     pg->SetLabel(this, labelSet.CatchBegin());
-    catchClause_->Compile(pg);
+    catch_clause_->Compile(pg);
     pg->SetLabel(this, labelSet.CatchEnd());
 }
 
 void TryStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
 {
     if (finalizer_) {
-        if (catchClause_) {
+        if (catch_clause_) {
             CompileTryCatchFinally(pg);
         } else {
             CompileTryFinally(pg);
@@ -159,8 +159,8 @@ checker::Type *TryStatement::Check([[maybe_unused]] checker::Checker *checker) c
 {
     block_->Check(checker);
 
-    if (catchClause_) {
-        catchClause_->Check(checker);
+    if (catch_clause_) {
+        catch_clause_->Check(checker);
     }
 
     if (finalizer_) {
diff --git a/ir/statements/tryStatement.h b/ir/statements/tryStatement.h
index c824b99db3b96e553fb9cc0c5d22731f765ca3e2..f41122e648277be1453aa41e99d3e10efe2e624c 100644
--- a/ir/statements/tryStatement.h
+++ b/ir/statements/tryStatement.h
@@ -37,7 +37,7 @@ class CatchClause;
 class TryStatement : public Statement {
 public:
     explicit TryStatement(BlockStatement *block, CatchClause *catchClause, BlockStatement *finalizer)
-        : Statement(AstNodeType::TRY_STATEMENT), block_(block), catchClause_(catchClause), finalizer_(finalizer)
+        : Statement(AstNodeType::TRY_STATEMENT), block_(block), catch_clause_(catchClause), finalizer_(finalizer)
     {
     }
 
@@ -53,7 +53,7 @@ public:
 
     CatchClause *GetCatchClause() const
     {
-        return catchClause_;
+        return catch_clause_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -69,7 +69,7 @@ private:
                         const compiler::TryLabelSet &labelSet) const;
 
     BlockStatement *block_;
-    CatchClause *catchClause_;
+    CatchClause *catch_clause_;
     BlockStatement *finalizer_;
 };
 
diff --git a/ir/statements/variableDeclaration.cpp b/ir/statements/variableDeclaration.cpp
index 0e987e9889eb65c24416c8a6913b4eaa8dfbd242..b9711cda01f6d76df2731532a314160af2746bcd 100644
--- a/ir/statements/variableDeclaration.cpp
+++ b/ir/statements/variableDeclaration.cpp
@@ -94,8 +94,8 @@ static TypeAnnotationDestructuringType GetTypeAnnotationNodeAndDestructuringType
 
     ASSERT(decl->Id()->IsIdentifier());
     binder::ScopeFindResult result = checker->Scope()->Find(decl->Id()->AsIdentifier()->Name());
-    ASSERT(result.variable);
-    return {result.variable, decl->Id()->AsIdentifier()->TypeAnnotation(),
+    ASSERT(result.variable_);
+    return {result.variable_, decl->Id()->AsIdentifier()->TypeAnnotation(),
             checker::DestructuringType::NO_DESTRUCTURING};
 }
 
diff --git a/ir/ts/tsArrayType.cpp b/ir/ts/tsArrayType.cpp
index 85fb3294f7f113a9fdee08d5d02dfa3280a32d3e..49a7d28a9c7216ee896960c1e483e899f3e8590c 100644
--- a/ir/ts/tsArrayType.cpp
+++ b/ir/ts/tsArrayType.cpp
@@ -21,12 +21,12 @@ namespace panda::es2panda::ir {
 
 void TSArrayType::Iterate(const NodeTraverser &cb) const
 {
-    cb(elementType_);
+    cb(element_type_);
 }
 
 void TSArrayType::Dump(ir::AstDumper *dumper) const
 {
-    dumper->Add({{"type", "TSArrayType"}, {"elementType", elementType_}});
+    dumper->Add({{"type", "TSArrayType"}, {"elementType", element_type_}});
 }
 
 void TSArrayType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsArrayType.h b/ir/ts/tsArrayType.h
index 3e550e6cdc26501d0799128f44e71dd90a25dcab..f18a09654586e6b295e03ac010909dfe8413fe6a 100644
--- a/ir/ts/tsArrayType.h
+++ b/ir/ts/tsArrayType.h
@@ -31,11 +31,13 @@ namespace panda::es2panda::ir {
 
 class TSArrayType : public Expression {
 public:
-    explicit TSArrayType(Expression *elementType) : Expression(AstNodeType::TS_ARRAY_TYPE), elementType_(elementType) {}
+    explicit TSArrayType(Expression *elementType) : Expression(AstNodeType::TS_ARRAY_TYPE), element_type_(elementType)
+    {
+    }
 
     const Expression *ElementType() const
     {
-        return elementType_;
+        return element_type_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -44,7 +46,7 @@ public:
     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
 
 private:
-    Expression *elementType_;
+    Expression *element_type_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsAsExpression.cpp b/ir/ts/tsAsExpression.cpp
index 1e32fa7b86c39c8a47ead8f092f4df2dc33e6cb6..273ee8cb05fcd16cfeee7ee1b3c4a05a8ad0dedc 100644
--- a/ir/ts/tsAsExpression.cpp
+++ b/ir/ts/tsAsExpression.cpp
@@ -27,12 +27,12 @@ namespace panda::es2panda::ir {
 void TSAsExpression::Iterate(const NodeTraverser &cb) const
 {
     cb(expression_);
-    cb(typeAnnotation_);
+    cb(type_annotation_);
 }
 
 void TSAsExpression::Dump(ir::AstDumper *dumper) const
 {
-    dumper->Add({{"type", "TSAsExpression"}, {"expression", expression_}, {"typeAnnotation", typeAnnotation_}});
+    dumper->Add({{"type", "TSAsExpression"}, {"expression", expression_}, {"typeAnnotation", type_annotation_}});
 }
 
 void TSAsExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
@@ -63,8 +63,8 @@ static bool IsValidConstAssertionArgument(checker::Checker *checker, const ir::A
             if (memberExpr->Object()->IsIdentifier()) {
                 binder::ScopeFindResult result = checker->Scope()->Find(memberExpr->Object()->AsIdentifier()->Name());
                 constexpr auto enumLiteralType = checker::EnumLiteralType::EnumLiteralTypeKind::LITERAL;
-                if (result.variable && result.variable->TsType()->HasTypeFlag(checker::TypeFlag::ENUM_LITERAL) &&
-                    result.variable->TsType()->AsEnumLiteralType()->Kind() == enumLiteralType) {
+                if (result.variable_ && result.variable_->TsType()->HasTypeFlag(checker::TypeFlag::ENUM_LITERAL) &&
+                    result.variable_->TsType()->AsEnumLiteralType()->Kind() == enumLiteralType) {
                     return true;
                 }
             }
@@ -80,7 +80,7 @@ checker::Type *TSAsExpression::Check([[maybe_unused]] checker::Checker *checker)
     // TODO(aszilagyi): params is_const_, is_const_
     checker::Type *exprType = expression_->Check(checker);
 
-    if (isConst_) {
+    if (is_const_) {
         if (!IsValidConstAssertionArgument(checker, expression_)) {
             checker->ThrowTypeError(
                 "A 'const' assertions can only be applied to references to enum members, or string, number, "
@@ -96,7 +96,7 @@ checker::Type *TSAsExpression::Check([[maybe_unused]] checker::Checker *checker)
         exprType->AsObjectType()->RemoveObjectFlag(checker::ObjectType::ObjectFlags::CHECK_EXCESS_PROPS);
     }
 
-    checker::Type *targetType = typeAnnotation_->Check(checker);
+    checker::Type *targetType = type_annotation_->Check(checker);
 
     checker->IsTypeComparableTo(
         targetType, exprType,
diff --git a/ir/ts/tsAsExpression.h b/ir/ts/tsAsExpression.h
index 43b5c8d311d974e176e064eef39b249a8db35a79..20c487280a54facba97540a9c5ec2d5050b05b32 100644
--- a/ir/ts/tsAsExpression.h
+++ b/ir/ts/tsAsExpression.h
@@ -35,8 +35,8 @@ public:
     explicit TSAsExpression(Expression *expression, Expression *typeAnnotation, bool isConst)
         : Expression(AstNodeType::TS_AS_EXPRESSION),
           expression_(expression),
-          typeAnnotation_(typeAnnotation),
-          isConst_(isConst)
+          type_annotation_(typeAnnotation),
+          is_const_(isConst)
     {
     }
 
@@ -47,12 +47,12 @@ public:
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     bool IsConst() const
     {
-        return isConst_;
+        return is_const_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -62,8 +62,8 @@ public:
 
 private:
     Expression *expression_;
-    Expression *typeAnnotation_;
-    bool isConst_;
+    Expression *type_annotation_;
+    bool is_const_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsClassImplements.cpp b/ir/ts/tsClassImplements.cpp
index c122178534eb8f1681d4e9196bec85466dced35f..866dc1117706624c55f5e59507d864fbe233ddba 100644
--- a/ir/ts/tsClassImplements.cpp
+++ b/ir/ts/tsClassImplements.cpp
@@ -25,8 +25,8 @@ void TSClassImplements::Iterate(const NodeTraverser &cb) const
 {
     cb(expression_);
 
-    if (typeParameters_) {
-        cb(typeParameters_);
+    if (type_parameters_) {
+        cb(type_parameters_);
     }
 }
 
@@ -34,7 +34,7 @@ void TSClassImplements::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TSClassImplements"},
                  {"expression", expression_},
-                 {"typeParameters", AstDumper::Optional(typeParameters_)}});
+                 {"typeParameters", AstDumper::Optional(type_parameters_)}});
 }
 
 void TSClassImplements::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsClassImplements.h b/ir/ts/tsClassImplements.h
index 3926e09ae838532532dd2b12c18cf5c1430b35ae..e4d2a65e216a6b7680596ce5fae1739136f7fae2 100644
--- a/ir/ts/tsClassImplements.h
+++ b/ir/ts/tsClassImplements.h
@@ -34,7 +34,7 @@ class TSTypeParameterInstantiation;
 class TSClassImplements : public Expression {
 public:
     explicit TSClassImplements(Expression *expression, TSTypeParameterInstantiation *typeParameters)
-        : Expression(AstNodeType::TS_AS_EXPRESSION), expression_(expression), typeParameters_(typeParameters)
+        : Expression(AstNodeType::TS_AS_EXPRESSION), expression_(expression), type_parameters_(typeParameters)
     {
     }
 
@@ -45,7 +45,7 @@ public:
 
     const TSTypeParameterInstantiation *TypeParameters() const
     {
-        return typeParameters_;
+        return type_parameters_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -55,7 +55,7 @@ public:
 
 private:
     Expression *expression_;
-    TSTypeParameterInstantiation *typeParameters_;
+    TSTypeParameterInstantiation *type_parameters_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsConditionalType.cpp b/ir/ts/tsConditionalType.cpp
index cbf616e0f879c0e971417a5030a8b1871b0d7626..31e4e26369410ef80c8c244ae0905b58c322e0f5 100644
--- a/ir/ts/tsConditionalType.cpp
+++ b/ir/ts/tsConditionalType.cpp
@@ -21,19 +21,19 @@ namespace panda::es2panda::ir {
 
 void TSConditionalType::Iterate(const NodeTraverser &cb) const
 {
-    cb(checkType_);
-    cb(extendsType_);
-    cb(trueType_);
-    cb(falseType_);
+    cb(check_type_);
+    cb(extends_type_);
+    cb(true_type_);
+    cb(false_type_);
 }
 
 void TSConditionalType::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TSConditionalType"},
-                 {"checkType", checkType_},
-                 {"extendsType", extendsType_},
-                 {"trueType", trueType_},
-                 {"falseType", falseType_}});
+                 {"checkType", check_type_},
+                 {"extendsType", extends_type_},
+                 {"trueType", true_type_},
+                 {"falseType", false_type_}});
 }
 
 void TSConditionalType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsConditionalType.h b/ir/ts/tsConditionalType.h
index 1a01ad7ff355923bf3135b26b0031709c2770e03..97efd2427e2b6c62e11e817f75ba32cbac18b5aa 100644
--- a/ir/ts/tsConditionalType.h
+++ b/ir/ts/tsConditionalType.h
@@ -34,31 +34,31 @@ public:
     explicit TSConditionalType(Expression *checkType, Expression *extendsType, Expression *trueType,
                                Expression *falseType)
         : Expression(AstNodeType::TS_CONDITIONAL_TYPE),
-          checkType_(checkType),
-          extendsType_(extendsType),
-          trueType_(trueType),
-          falseType_(falseType)
+          check_type_(checkType),
+          extends_type_(extendsType),
+          true_type_(trueType),
+          false_type_(falseType)
     {
     }
 
     const Expression *CheckType() const
     {
-        return checkType_;
+        return check_type_;
     }
 
     const Expression *ExtendsType() const
     {
-        return extendsType_;
+        return extends_type_;
     }
 
     const Expression *TrueType() const
     {
-        return trueType_;
+        return true_type_;
     }
 
     const Expression *FalseType() const
     {
-        return falseType_;
+        return false_type_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -67,10 +67,10 @@ public:
     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
 
 private:
-    Expression *checkType_;
-    Expression *extendsType_;
-    Expression *trueType_;
-    Expression *falseType_;
+    Expression *check_type_;
+    Expression *extends_type_;
+    Expression *true_type_;
+    Expression *false_type_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsConstructorType.cpp b/ir/ts/tsConstructorType.cpp
index 61d9544af3b68a59893d222b3c886c19e80dc3fd..3ddbc3963bd8afc178b7ea62293ff96e12b5b6a0 100644
--- a/ir/ts/tsConstructorType.cpp
+++ b/ir/ts/tsConstructorType.cpp
@@ -26,23 +26,23 @@ namespace panda::es2panda::ir {
 
 void TSConstructorType::Iterate(const NodeTraverser &cb) const
 {
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
     for (auto *it : params_) {
         cb(it);
     }
 
-    cb(returnType_);
+    cb(return_type_);
 }
 
 void TSConstructorType::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TSConstructorType"},
                  {"params", params_},
-                 {"typeParameters", AstDumper::Optional(typeParams_)},
-                 {"returnType", returnType_},
+                 {"typeParameters", AstDumper::Optional(type_params_)},
+                 {"returnType", return_type_},
                  {"abstract", AstDumper::Optional(abstract_)}});
 }
 
@@ -54,7 +54,7 @@ checker::Type *TSConstructorType::Check(checker::Checker *checker) const
 
     auto *signatureInfo = checker->Allocator()->New<checker::SignatureInfo>();
     checker->CheckFunctionParameterDeclaration(params_, signatureInfo);
-    checker::Type *returnType = returnType_->Check(checker);
+    checker::Type *returnType = return_type_->Check(checker);
     auto *constructSignature = checker->Allocator()->New<checker::Signature>(signatureInfo, returnType);
 
     return checker->CreateConstructorTypeWithSignature(constructSignature);
diff --git a/ir/ts/tsConstructorType.h b/ir/ts/tsConstructorType.h
index fcb3b70a082b6fe8a0906fc2bff047211bb1d629..652cd70a22d1540d0f78e4b82384c56321c08dfd 100644
--- a/ir/ts/tsConstructorType.h
+++ b/ir/ts/tsConstructorType.h
@@ -42,8 +42,8 @@ public:
         : Expression(AstNodeType::TS_CONSTRUCTOR_TYPE),
           scope_(scope),
           params_(std::move(params)),
-          typeParams_(typeParams),
-          returnType_(returnType),
+          type_params_(typeParams),
+          return_type_(returnType),
           abstract_(abstract)
     {
     }
@@ -55,7 +55,7 @@ public:
 
     const TSTypeParameterDeclaration *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     const ArenaVector<Expression *> &Params() const
@@ -65,7 +65,7 @@ public:
 
     const Expression *ReturnType() const
     {
-        return returnType_;
+        return return_type_;
     }
 
     bool Abstract() const
@@ -81,8 +81,8 @@ public:
 private:
     binder::Scope *scope_;
     ArenaVector<Expression *> params_;
-    TSTypeParameterDeclaration *typeParams_;
-    Expression *returnType_;
+    TSTypeParameterDeclaration *type_params_;
+    Expression *return_type_;
     bool abstract_;
 };
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsEnumDeclaration.cpp b/ir/ts/tsEnumDeclaration.cpp
index d92e673a355032b7a0c7f443f4cdd9f5e20b01d1..041b1c42a7dd37294b0bb6c0d18f5fdd7fae65b6 100644
--- a/ir/ts/tsEnumDeclaration.cpp
+++ b/ir/ts/tsEnumDeclaration.cpp
@@ -41,7 +41,7 @@ void TSEnumDeclaration::Iterate(const NodeTraverser &cb) const
 
 void TSEnumDeclaration::Dump(ir::AstDumper *dumper) const
 {
-    dumper->Add({{"type", "TSEnumDeclaration"}, {"id", key_}, {"members", members_}, {"const", isConst_}});
+    dumper->Add({{"type", "TSEnumDeclaration"}, {"id", key_}, {"members", members_}, {"const", is_const_}});
 }
 
 void TSEnumDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
@@ -390,7 +390,7 @@ checker::Type *TSEnumDeclaration::Check([[maybe_unused]] checker::Checker *check
 
     if (!enumVar->TsType()) {
         checker::ScopeContext scopeCtx(checker, scope_);
-        checker::Type *enumType = InferType(checker, isConst_);
+        checker::Type *enumType = InferType(checker, is_const_);
         enumType->SetVariable(enumVar);
         enumVar->SetTsType(enumType);
     }
diff --git a/ir/ts/tsEnumDeclaration.h b/ir/ts/tsEnumDeclaration.h
index 6baa9c7ccc40883a0c59de795a2dde632a4cdee1..59135a9283dd9e72f3de28b863513378035abfe1 100644
--- a/ir/ts/tsEnumDeclaration.h
+++ b/ir/ts/tsEnumDeclaration.h
@@ -46,7 +46,7 @@ public:
           scope_(scope),
           key_(key),
           members_(std::move(members)),
-          isConst_(isConst)
+          is_const_(isConst)
     {
     }
 
@@ -67,7 +67,7 @@ public:
 
     bool IsConst() const
     {
-        return isConst_;
+        return is_const_;
     }
 
     static binder::EnumMemberResult EvaluateEnumMember(checker::Checker *checker, binder::EnumVariable *enumVar,
@@ -83,7 +83,7 @@ private:
     binder::LocalScope *scope_;
     Identifier *key_;
     ArenaVector<TSEnumMember *> members_;
-    bool isConst_;
+    bool is_const_;
 };
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsFunctionType.cpp b/ir/ts/tsFunctionType.cpp
index 43e12a305adcd1f0e0c69cea75a20fe33129e7a8..9e21e828a0bc9350e68b2663458235f86a96fca2 100644
--- a/ir/ts/tsFunctionType.cpp
+++ b/ir/ts/tsFunctionType.cpp
@@ -26,23 +26,23 @@ namespace panda::es2panda::ir {
 
 void TSFunctionType::Iterate(const NodeTraverser &cb) const
 {
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
     for (auto *it : params_) {
         cb(it);
     }
 
-    cb(returnType_);
+    cb(return_type_);
 }
 
 void TSFunctionType::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TSFunctionType"},
                  {"params", params_},
-                 {"typeParameters", AstDumper::Optional(typeParams_)},
-                 {"returnType", returnType_}});
+                 {"typeParameters", AstDumper::Optional(type_params_)},
+                 {"returnType", return_type_}});
 }
 
 void TSFunctionType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
@@ -53,7 +53,7 @@ checker::Type *TSFunctionType::Check(checker::Checker *checker) const
 
     auto *signatureInfo = checker->Allocator()->New<checker::SignatureInfo>();
     checker->CheckFunctionParameterDeclaration(params_, signatureInfo);
-    checker::Type *returnType = returnType_->Check(checker);
+    checker::Type *returnType = return_type_->Check(checker);
     auto *callSignature = checker->Allocator()->New<checker::Signature>(signatureInfo, returnType);
 
     return checker->CreateFunctionTypeWithSignature(callSignature);
diff --git a/ir/ts/tsFunctionType.h b/ir/ts/tsFunctionType.h
index 49f9d9fc8950259bafbfa00ad5c8cbf8640c1fe7..e882e4ffad3e88f3c8f886cc6988931cde6efefb 100644
--- a/ir/ts/tsFunctionType.h
+++ b/ir/ts/tsFunctionType.h
@@ -42,8 +42,8 @@ public:
         : Expression(AstNodeType::TS_FUNCTION_TYPE),
           scope_(scope),
           params_(std::move(params)),
-          typeParams_(typeParams),
-          returnType_(returnType)
+          type_params_(typeParams),
+          return_type_(returnType)
     {
     }
 
@@ -54,7 +54,7 @@ public:
 
     const TSTypeParameterDeclaration *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     const ArenaVector<Expression *> &Params() const
@@ -64,7 +64,7 @@ public:
 
     const Expression *ReturnType() const
     {
-        return returnType_;
+        return return_type_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -75,8 +75,8 @@ public:
 private:
     binder::Scope *scope_;
     ArenaVector<Expression *> params_;
-    TSTypeParameterDeclaration *typeParams_;
-    Expression *returnType_;
+    TSTypeParameterDeclaration *type_params_;
+    Expression *return_type_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsImportEqualsDeclaration.cpp b/ir/ts/tsImportEqualsDeclaration.cpp
index 89b612bc1d711f37081f8bb70bc4010b2b8e264d..e0b74f23a431a8a1a3b8346589920c542735b5c9 100644
--- a/ir/ts/tsImportEqualsDeclaration.cpp
+++ b/ir/ts/tsImportEqualsDeclaration.cpp
@@ -24,15 +24,15 @@ namespace panda::es2panda::ir {
 void TSImportEqualsDeclaration::Iterate(const NodeTraverser &cb) const
 {
     cb(id_);
-    cb(moduleReference_);
+    cb(module_reference_);
 }
 
 void TSImportEqualsDeclaration::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TSImportEqualsDeclaration"},
                  {"id", id_},
-                 {"moduleReference", moduleReference_},
-                 {"isExport", isExport_}});
+                 {"moduleReference", module_reference_},
+                 {"isExport", is_export_}});
 }
 
 void TSImportEqualsDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsImportEqualsDeclaration.h b/ir/ts/tsImportEqualsDeclaration.h
index 8bcd9e65ca778243c709d6595f8738fe018edfb4..5a61571a9b42e03ea7d944a76232af98560819de 100644
--- a/ir/ts/tsImportEqualsDeclaration.h
+++ b/ir/ts/tsImportEqualsDeclaration.h
@@ -36,8 +36,8 @@ public:
     explicit TSImportEqualsDeclaration(Identifier *id, Expression *moduleReference, bool isExport)
         : Statement(AstNodeType::TS_IMPORT_EQUALS_DECLARATION),
           id_(id),
-          moduleReference_(moduleReference),
-          isExport_(isExport)
+          module_reference_(moduleReference),
+          is_export_(isExport)
     {
     }
 
@@ -48,12 +48,12 @@ public:
 
     const Expression *ModuleReference() const
     {
-        return moduleReference_;
+        return module_reference_;
     }
 
     bool IsExport() const
     {
-        return isExport_;
+        return is_export_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -63,8 +63,8 @@ public:
 
 private:
     Identifier *id_;
-    Expression *moduleReference_;
-    bool isExport_;
+    Expression *module_reference_;
+    bool is_export_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsImportType.cpp b/ir/ts/tsImportType.cpp
index 06b65b31a3a8b8ac98bedc605d205c840db07e3d..290d3d82494efcc505f409b0220eeec30e5c693a 100644
--- a/ir/ts/tsImportType.cpp
+++ b/ir/ts/tsImportType.cpp
@@ -25,8 +25,8 @@ void TSImportType::Iterate(const NodeTraverser &cb) const
 {
     cb(param_);
 
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
     if (qualifier_) {
@@ -39,8 +39,8 @@ void TSImportType::Dump(ir::AstDumper *dumper) const
     dumper->Add({{"type", "TSImportType"},
                  {"parameter", param_},
                  {"qualifier", AstDumper::Optional(qualifier_)},
-                 {"typeParameters", AstDumper::Optional(typeParams_)},
-                 {"isTypeOf", isTypeof_}});
+                 {"typeParameters", AstDumper::Optional(type_params_)},
+                 {"isTypeOf", is_typeof_}});
 }
 
 void TSImportType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsImportType.h b/ir/ts/tsImportType.h
index 08a6c675aa2d118370b55cd2eaa215d92a285755..5e8d7442b84a73861887d6ceda50baa1244d3d09 100644
--- a/ir/ts/tsImportType.h
+++ b/ir/ts/tsImportType.h
@@ -37,9 +37,9 @@ public:
                           bool isTypeof)
         : Expression(AstNodeType::TS_IMPORT_TYPE),
           param_(param),
-          typeParams_(typeParams),
+          type_params_(typeParams),
           qualifier_(qualifier),
-          isTypeof_(isTypeof)
+          is_typeof_(isTypeof)
     {
     }
 
@@ -50,7 +50,7 @@ public:
 
     const TSTypeParameterInstantiation *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     const Expression *Qualifier() const
@@ -60,7 +60,7 @@ public:
 
     bool IsTypeof() const
     {
-        return isTypeof_;
+        return is_typeof_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -70,9 +70,9 @@ public:
 
 private:
     Expression *param_;
-    TSTypeParameterInstantiation *typeParams_;
+    TSTypeParameterInstantiation *type_params_;
     Expression *qualifier_;
-    bool isTypeof_;
+    bool is_typeof_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsIndexSignature.cpp b/ir/ts/tsIndexSignature.cpp
index 67c106b1214e040b120f870333416279b176ed76..7fdda322416932c7fbb1fa9d508a5530ab116455 100644
--- a/ir/ts/tsIndexSignature.cpp
+++ b/ir/ts/tsIndexSignature.cpp
@@ -29,14 +29,14 @@ TSIndexSignature::TSIndexSignatureKind TSIndexSignature::Kind() const
 void TSIndexSignature::Iterate(const NodeTraverser &cb) const
 {
     cb(param_);
-    cb(typeAnnotation_);
+    cb(type_annotation_);
 }
 
 void TSIndexSignature::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TSIndexSignature"},
                  {"parameters", param_},
-                 {"typeAnnotation", typeAnnotation_},
+                 {"typeAnnotation", type_annotation_},
                  {"readonly", readonly_}});
 }
 
diff --git a/ir/ts/tsIndexSignature.h b/ir/ts/tsIndexSignature.h
index 334b042033c3069f8e63e17d059de8fc9a07bff3..0dbac3246f64aa4290c79f0cdea1e5a77bea2fe6 100644
--- a/ir/ts/tsIndexSignature.h
+++ b/ir/ts/tsIndexSignature.h
@@ -36,7 +36,7 @@ public:
     explicit TSIndexSignature(Expression *param, Expression *typeAnnotation, bool readonly)
         : Expression(AstNodeType::TS_INDEX_SIGNATURE),
           param_(param),
-          typeAnnotation_(typeAnnotation),
+          type_annotation_(typeAnnotation),
           readonly_(readonly)
     {
     }
@@ -48,7 +48,7 @@ public:
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     bool Readonly() const
@@ -65,7 +65,7 @@ public:
 
 private:
     Expression *param_;
-    Expression *typeAnnotation_;
+    Expression *type_annotation_;
     bool readonly_;
 };
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsIndexedAccessType.cpp b/ir/ts/tsIndexedAccessType.cpp
index 2e55dce32d7dc5e02c0c5ef9298160d7ab88bef6..4859c3cc852278581d57ee755e9f6585f3481db3 100644
--- a/ir/ts/tsIndexedAccessType.cpp
+++ b/ir/ts/tsIndexedAccessType.cpp
@@ -22,21 +22,21 @@ namespace panda::es2panda::ir {
 
 void TSIndexedAccessType::Iterate(const NodeTraverser &cb) const
 {
-    cb(objectType_);
-    cb(indexType_);
+    cb(object_type_);
+    cb(index_type_);
 }
 
 void TSIndexedAccessType::Dump(ir::AstDumper *dumper) const
 {
-    dumper->Add({{"type", "TSIndexedAccessType"}, {"objectType", objectType_}, {"indexType", indexType_}});
+    dumper->Add({{"type", "TSIndexedAccessType"}, {"objectType", object_type_}, {"indexType", index_type_}});
 }
 
 void TSIndexedAccessType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
 
 checker::Type *TSIndexedAccessType::Check([[maybe_unused]] checker::Checker *checker) const
 {
-    checker::Type *baseType = objectType_->Check(checker);
-    checker::Type *propType = checker->ResolveBaseProp(baseType, indexType_, false, Start());
+    checker::Type *baseType = object_type_->Check(checker);
+    checker::Type *propType = checker->ResolveBaseProp(baseType, index_type_, false, Start());
 
     return propType;
 }
diff --git a/ir/ts/tsIndexedAccessType.h b/ir/ts/tsIndexedAccessType.h
index 20ca95fe004b37de5572c00efef1fa5be10dae91..5568a8e1d9710e2399d330e0bb6597ad18d96c96 100644
--- a/ir/ts/tsIndexedAccessType.h
+++ b/ir/ts/tsIndexedAccessType.h
@@ -32,18 +32,18 @@ namespace panda::es2panda::ir {
 class TSIndexedAccessType : public Expression {
 public:
     explicit TSIndexedAccessType(Expression *objectType, Expression *indexType)
-        : Expression(AstNodeType::TS_INDEXED_ACCESS_TYPE), objectType_(objectType), indexType_(indexType)
+        : Expression(AstNodeType::TS_INDEXED_ACCESS_TYPE), object_type_(objectType), index_type_(indexType)
     {
     }
 
     const Expression *ObjectType() const
     {
-        return objectType_;
+        return object_type_;
     }
 
     const Expression *IndexType() const
     {
-        return indexType_;
+        return index_type_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -52,8 +52,8 @@ public:
     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
 
 private:
-    Expression *objectType_;
-    Expression *indexType_;
+    Expression *object_type_;
+    Expression *index_type_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsInferType.cpp b/ir/ts/tsInferType.cpp
index e549496ca53fb4eb8f5141b4ae2f62f388193f00..b8b5afc1b9e93c2ef13346ece4901d417672d7ea 100644
--- a/ir/ts/tsInferType.cpp
+++ b/ir/ts/tsInferType.cpp
@@ -22,12 +22,12 @@ namespace panda::es2panda::ir {
 
 void TSInferType::Iterate(const NodeTraverser &cb) const
 {
-    cb(typeParam_);
+    cb(type_param_);
 }
 
 void TSInferType::Dump(ir::AstDumper *dumper) const
 {
-    dumper->Add({{"type", "TSInferType"}, {"typeParameter", typeParam_}});
+    dumper->Add({{"type", "TSInferType"}, {"typeParameter", type_param_}});
 }
 
 void TSInferType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsInferType.h b/ir/ts/tsInferType.h
index a454774c59ab9068a7c7848da25b08a4a014aa00..22c46b415f9085ccc5558c2e47d3c053595eaa07 100644
--- a/ir/ts/tsInferType.h
+++ b/ir/ts/tsInferType.h
@@ -33,11 +33,11 @@ class TSTypeParameter;
 
 class TSInferType : public Expression {
 public:
-    explicit TSInferType(TSTypeParameter *typeParam) : Expression(AstNodeType::TS_INFER_TYPE), typeParam_(typeParam) {}
+    explicit TSInferType(TSTypeParameter *typeParam) : Expression(AstNodeType::TS_INFER_TYPE), type_param_(typeParam) {}
 
     const TSTypeParameter *TypeParam() const
     {
-        return typeParam_;
+        return type_param_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -46,7 +46,7 @@ public:
     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
 
 private:
-    TSTypeParameter *typeParam_;
+    TSTypeParameter *type_param_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsInterfaceDeclaration.cpp b/ir/ts/tsInterfaceDeclaration.cpp
index 4974d7282a1bb241b8148c4359e9b574e84f36e8..3c0587a8ab1300c3e0fce0b929af9d08221d3bc1 100644
--- a/ir/ts/tsInterfaceDeclaration.cpp
+++ b/ir/ts/tsInterfaceDeclaration.cpp
@@ -32,8 +32,8 @@ void TSInterfaceDeclaration::Iterate(const NodeTraverser &cb) const
 {
     cb(id_);
 
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
     cb(body_);
@@ -49,7 +49,7 @@ void TSInterfaceDeclaration::Dump(ir::AstDumper *dumper) const
                  {"body", body_},
                  {"id", id_},
                  {"extends", extends_},
-                 {"typeParameters", AstDumper::Optional(typeParams_)}});
+                 {"typeParameters", AstDumper::Optional(type_params_)}});
 }
 
 void TSInterfaceDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsInterfaceDeclaration.h b/ir/ts/tsInterfaceDeclaration.h
index e613ae1346177db6f56bed5b8ea1aafeb402af54..c890323e90931c31895f476ca3f32677a31c4a6a 100644
--- a/ir/ts/tsInterfaceDeclaration.h
+++ b/ir/ts/tsInterfaceDeclaration.h
@@ -46,7 +46,7 @@ public:
         : Statement(AstNodeType::TS_INTERFACE_DECLARATION),
           scope_(scope),
           id_(id),
-          typeParams_(typeParams),
+          type_params_(typeParams),
           body_(body),
           extends_(std::move(extends))
     {
@@ -69,7 +69,7 @@ public:
 
     const TSTypeParameterDeclaration *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     const ArenaVector<TSInterfaceHeritage *> &Extends() const
@@ -86,7 +86,7 @@ public:
 private:
     binder::LocalScope *scope_;
     Identifier *id_;
-    TSTypeParameterDeclaration *typeParams_;
+    TSTypeParameterDeclaration *type_params_;
     TSInterfaceBody *body_;
     ArenaVector<TSInterfaceHeritage *> extends_;
 };
diff --git a/ir/ts/tsInterfaceHeritage.cpp b/ir/ts/tsInterfaceHeritage.cpp
index 79d8e44b09a5a9184a2c3b6f0fbf59b1e9ec0906..6daafa66f977267f7c3413837984564fd505ef65 100644
--- a/ir/ts/tsInterfaceHeritage.cpp
+++ b/ir/ts/tsInterfaceHeritage.cpp
@@ -28,15 +28,16 @@ void TSInterfaceHeritage::Iterate(const NodeTraverser &cb) const
 {
     cb(expr_);
 
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 }
 
 void TSInterfaceHeritage::Dump(ir::AstDumper *dumper) const
 {
-    dumper->Add(
-        {{"type", "TSInterfaceHeritage"}, {"expression", expr_}, {"typeParameters", AstDumper::Optional(typeParams_)}});
+    dumper->Add({{"type", "TSInterfaceHeritage"},
+                 {"expression", expr_},
+                 {"typeParameters", AstDumper::Optional(type_params_)}});
 }
 
 void TSInterfaceHeritage::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsInterfaceHeritage.h b/ir/ts/tsInterfaceHeritage.h
index fb2a86d4fb7781f62639357473c8c42d8f405cc7..a314b264923df3749394f95e0c0f2f70a7952d46 100644
--- a/ir/ts/tsInterfaceHeritage.h
+++ b/ir/ts/tsInterfaceHeritage.h
@@ -35,7 +35,7 @@ class TSTypeParameterInstantiation;
 class TSInterfaceHeritage : public Expression {
 public:
     explicit TSInterfaceHeritage(Expression *expr, TSTypeParameterInstantiation *typeParams)
-        : Expression(AstNodeType::TS_INTERFACE_HERITAGE), expr_(expr), typeParams_(typeParams)
+        : Expression(AstNodeType::TS_INTERFACE_HERITAGE), expr_(expr), type_params_(typeParams)
     {
     }
 
@@ -46,7 +46,7 @@ public:
 
     const TSTypeParameterInstantiation *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -56,7 +56,7 @@ public:
 
 private:
     Expression *expr_;
-    TSTypeParameterInstantiation *typeParams_;
+    TSTypeParameterInstantiation *type_params_;
 };
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsMappedType.cpp b/ir/ts/tsMappedType.cpp
index 9fd99c5a71ea2b5571e8553940b766b072514ec0..0f48aacd172bcc594ec459cc83a03a16869bea37 100644
--- a/ir/ts/tsMappedType.cpp
+++ b/ir/ts/tsMappedType.cpp
@@ -22,17 +22,17 @@ namespace panda::es2panda::ir {
 
 void TSMappedType::Iterate(const NodeTraverser &cb) const
 {
-    cb(typeParameter_);
-    if (typeAnnotation_) {
-        cb(typeAnnotation_);
+    cb(type_parameter_);
+    if (type_annotation_) {
+        cb(type_annotation_);
     }
 }
 
 void TSMappedType::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TSMappedType"},
-                 {"typeParameter", typeParameter_},
-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
+                 {"typeParameter", type_parameter_},
+                 {"typeAnnotation", AstDumper::Optional(type_annotation_)},
                  {"readonly", readonly_ == MappedOption::NO_OPTS ? AstDumper::Optional(false)
                               : readonly_ == MappedOption::PLUS  ? AstDumper::Optional("+")
                                                                  : AstDumper::Optional("-")},
diff --git a/ir/ts/tsMappedType.h b/ir/ts/tsMappedType.h
index 6fe44032e2b9e37b5ad81b53d52d407289e2e475..29c9ce92a17e0c60274382429cffb96e2311110b 100644
--- a/ir/ts/tsMappedType.h
+++ b/ir/ts/tsMappedType.h
@@ -35,8 +35,8 @@ public:
     explicit TSMappedType(TSTypeParameter *typeParameter, Expression *typeAnnotation, MappedOption readonly,
                           MappedOption optional)
         : Expression(AstNodeType::TS_MAPPED_TYPE),
-          typeParameter_(typeParameter),
-          typeAnnotation_(typeAnnotation),
+          type_parameter_(typeParameter),
+          type_annotation_(typeAnnotation),
           readonly_(readonly),
           optional_(optional)
     {
@@ -44,12 +44,12 @@ public:
 
     TSTypeParameter *TypeParameter()
     {
-        return typeParameter_;
+        return type_parameter_;
     }
 
     Expression *TypeAnnotation()
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     MappedOption Readonly()
@@ -68,8 +68,8 @@ public:
     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
 
 private:
-    TSTypeParameter *typeParameter_;
-    Expression *typeAnnotation_;
+    TSTypeParameter *type_parameter_;
+    Expression *type_annotation_;
     MappedOption readonly_;
     MappedOption optional_;
 };
diff --git a/ir/ts/tsMethodSignature.cpp b/ir/ts/tsMethodSignature.cpp
index ee83c851de19b6fc0bcfa5d32f7e62dfaef15960..6da39980a30847f87fc0a97beb8da591ee2d537b 100644
--- a/ir/ts/tsMethodSignature.cpp
+++ b/ir/ts/tsMethodSignature.cpp
@@ -26,16 +26,16 @@ void TSMethodSignature::Iterate(const NodeTraverser &cb) const
 {
     cb(key_);
 
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
     for (auto *it : params_) {
         cb(it);
     }
 
-    if (returnTypeAnnotation_) {
-        cb(returnTypeAnnotation_);
+    if (return_type_annotation_) {
+        cb(return_type_annotation_);
     }
 }
 
@@ -46,8 +46,8 @@ void TSMethodSignature::Dump(ir::AstDumper *dumper) const
                  {"optional", optional_},
                  {"key", key_},
                  {"params", params_},
-                 {"typeParameters", AstDumper::Optional(typeParams_)},
-                 {"typeAnnotation", AstDumper::Optional(returnTypeAnnotation_)}});
+                 {"typeParameters", AstDumper::Optional(type_params_)},
+                 {"typeAnnotation", AstDumper::Optional(return_type_annotation_)}});
 }
 
 void TSMethodSignature::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsMethodSignature.h b/ir/ts/tsMethodSignature.h
index 6f13eb00b2187c3ea7ab8311df4ec7a52dab5738..3bbce7757d5e63fee1bbb33f992059ed9fa713be 100644
--- a/ir/ts/tsMethodSignature.h
+++ b/ir/ts/tsMethodSignature.h
@@ -43,9 +43,9 @@ public:
         : Expression(AstNodeType::TS_METHOD_SIGNATURE),
           scope_(scope),
           key_(key),
-          typeParams_(typeParams),
+          type_params_(typeParams),
           params_(std::move(params)),
-          returnTypeAnnotation_(returnTypeAnnotation),
+          return_type_annotation_(returnTypeAnnotation),
           computed_(computed),
           optional_(optional)
     {
@@ -63,7 +63,7 @@ public:
 
     const TSTypeParameterDeclaration *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     const ArenaVector<Expression *> &Params() const
@@ -73,7 +73,7 @@ public:
 
     const Expression *ReturnTypeAnnotation() const
     {
-        return returnTypeAnnotation_;
+        return return_type_annotation_;
     }
 
     bool Computed() const
@@ -94,9 +94,9 @@ public:
 private:
     binder::Scope *scope_;
     Expression *key_;
-    TSTypeParameterDeclaration *typeParams_;
+    TSTypeParameterDeclaration *type_params_;
     ArenaVector<Expression *> params_;
-    Expression *returnTypeAnnotation_;
+    Expression *return_type_annotation_;
     bool computed_;
     bool optional_;
 };
diff --git a/ir/ts/tsNamedTupleMember.cpp b/ir/ts/tsNamedTupleMember.cpp
index 712e44530b6f2f58a74b40d7f9cb72d06fb940c1..bb49deb06f0613acb9386d10deea12da1fd33567 100644
--- a/ir/ts/tsNamedTupleMember.cpp
+++ b/ir/ts/tsNamedTupleMember.cpp
@@ -22,13 +22,13 @@ namespace panda::es2panda::ir {
 void TSNamedTupleMember::Iterate(const NodeTraverser &cb) const
 {
     cb(label_);
-    cb(elementType_);
+    cb(element_type_);
 }
 
 void TSNamedTupleMember::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TSNamedTupleMember"},
-                 {"elementType", elementType_},
+                 {"elementType", element_type_},
                  {"label", label_},
                  {"optional", AstDumper::Optional(optional_)}});
 }
diff --git a/ir/ts/tsNamedTupleMember.h b/ir/ts/tsNamedTupleMember.h
index 9c900a370a0fb30f1d74496f93118064ef562446..45716abc1aadbec4e4bcc82841d4b49b5b4d626b 100644
--- a/ir/ts/tsNamedTupleMember.h
+++ b/ir/ts/tsNamedTupleMember.h
@@ -32,7 +32,7 @@ namespace panda::es2panda::ir {
 class TSNamedTupleMember : public Expression {
 public:
     explicit TSNamedTupleMember(Expression *label, Expression *elementType, bool optional)
-        : Expression(AstNodeType::TS_NAMED_TUPLE_MEMBER), label_(label), elementType_(elementType), optional_(optional)
+        : Expression(AstNodeType::TS_NAMED_TUPLE_MEMBER), label_(label), element_type_(elementType), optional_(optional)
     {
     }
 
@@ -43,7 +43,7 @@ public:
 
     const Expression *ElementType() const
     {
-        return elementType_;
+        return element_type_;
     }
 
     bool IsOptional() const
@@ -58,7 +58,7 @@ public:
 
 private:
     Expression *label_;
-    Expression *elementType_;
+    Expression *element_type_;
     bool optional_;
 };
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsPrivateIdentifier.cpp b/ir/ts/tsPrivateIdentifier.cpp
index e510353450b25df865893eea233bd3f825a860c2..c3bc1a445759a6c364e6f6f403e2ae6848eb997f 100644
--- a/ir/ts/tsPrivateIdentifier.cpp
+++ b/ir/ts/tsPrivateIdentifier.cpp
@@ -27,8 +27,8 @@ void TSPrivateIdentifier::Iterate(const NodeTraverser &cb) const
         cb(value_);
     }
 
-    if (typeAnnotation_) {
-        cb(typeAnnotation_);
+    if (type_annotation_) {
+        cb(type_annotation_);
     }
 }
 
@@ -37,7 +37,7 @@ void TSPrivateIdentifier::Dump(ir::AstDumper *dumper) const
     dumper->Add({{"type", "TSPrivateIdentifier"},
                  {"key", key_},
                  {"value", AstDumper::Optional(value_)},
-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)}});
+                 {"typeAnnotation", AstDumper::Optional(type_annotation_)}});
 }
 
 void TSPrivateIdentifier::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsPrivateIdentifier.h b/ir/ts/tsPrivateIdentifier.h
index e4872d5a8f204e60e4b10b25b0908693cd81dfe5..e3568161227841c68219bd215a6ed8a5f5d1f887 100644
--- a/ir/ts/tsPrivateIdentifier.h
+++ b/ir/ts/tsPrivateIdentifier.h
@@ -32,7 +32,7 @@ namespace panda::es2panda::ir {
 class TSPrivateIdentifier : public Expression {
 public:
     explicit TSPrivateIdentifier(Expression *key, Expression *value, Expression *typeAnnotation)
-        : Expression(AstNodeType::TS_PRIVATE_IDENTIFIER), key_(key), value_(value), typeAnnotation_(typeAnnotation)
+        : Expression(AstNodeType::TS_PRIVATE_IDENTIFIER), key_(key), value_(value), type_annotation_(typeAnnotation)
     {
     }
 
@@ -48,7 +48,7 @@ public:
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -59,7 +59,7 @@ public:
 private:
     Expression *key_;
     Expression *value_;
-    Expression *typeAnnotation_;
+    Expression *type_annotation_;
 };
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsPropertySignature.cpp b/ir/ts/tsPropertySignature.cpp
index 1e91a37a8785ba74c584677e0a95f6984fb42ccd..6288866200bb5391218aa69e86afe9433cf927b0 100644
--- a/ir/ts/tsPropertySignature.cpp
+++ b/ir/ts/tsPropertySignature.cpp
@@ -23,8 +23,8 @@ void TSPropertySignature::Iterate(const NodeTraverser &cb) const
 {
     cb(key_);
 
-    if (typeAnnotation_) {
-        cb(typeAnnotation_);
+    if (type_annotation_) {
+        cb(type_annotation_);
     }
 }
 
@@ -35,7 +35,7 @@ void TSPropertySignature::Dump(ir::AstDumper *dumper) const
                  {"optional", optional_},
                  {"readonly", readonly_},
                  {"key", key_},
-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)}});
+                 {"typeAnnotation", AstDumper::Optional(type_annotation_)}});
 }
 
 void TSPropertySignature::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsPropertySignature.h b/ir/ts/tsPropertySignature.h
index 9b9b9a068c69b53d7aeb69d596704acefd0d89b6..7ed401a230bd1f91f9e7e7e2ab6aeb1bcaeb429c 100644
--- a/ir/ts/tsPropertySignature.h
+++ b/ir/ts/tsPropertySignature.h
@@ -35,7 +35,7 @@ public:
                                  bool readonly)
         : Expression(AstNodeType::TS_PROPERTY_SIGNATURE),
           key_(key),
-          typeAnnotation_(typeAnnotation),
+          type_annotation_(typeAnnotation),
           computed_(computed),
           optional_(optional),
           readonly_(readonly)
@@ -49,7 +49,7 @@ public:
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     bool Computed() const
@@ -74,7 +74,7 @@ public:
 
 private:
     Expression *key_;
-    Expression *typeAnnotation_;
+    Expression *type_annotation_;
     bool computed_;
     bool optional_;
     bool readonly_;
diff --git a/ir/ts/tsSignatureDeclaration.cpp b/ir/ts/tsSignatureDeclaration.cpp
index 1269e945c29a29870dfad48ad51ee8e9f99c4815..fc66598e790a64f4bd0f4864a35b2ca9961a071a 100644
--- a/ir/ts/tsSignatureDeclaration.cpp
+++ b/ir/ts/tsSignatureDeclaration.cpp
@@ -24,16 +24,16 @@ namespace panda::es2panda::ir {
 
 void TSSignatureDeclaration::Iterate(const NodeTraverser &cb) const
 {
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
     for (auto *it : params_) {
         cb(it);
     }
 
-    if (returnTypeAnnotation_) {
-        cb(returnTypeAnnotation_);
+    if (return_type_annotation_) {
+        cb(return_type_annotation_);
     }
 }
 
@@ -43,8 +43,8 @@ void TSSignatureDeclaration::Dump(ir::AstDumper *dumper) const
                               ? "TSCallSignatureDeclaration"
                               : "TSConstructSignatureDeclaration"},
                  {"params", params_},
-                 {"typeParameters", AstDumper::Optional(typeParams_)},
-                 {"returnType", AstDumper::Optional(returnTypeAnnotation_)}});
+                 {"typeParameters", AstDumper::Optional(type_params_)},
+                 {"returnType", AstDumper::Optional(return_type_annotation_)}});
 }
 
 void TSSignatureDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsSignatureDeclaration.h b/ir/ts/tsSignatureDeclaration.h
index 85a8fe62853c2e6b35849458c72cb2fd9404513d..6ec14f80c9a458e7f1a3197cd9e32eb2db587b1b 100644
--- a/ir/ts/tsSignatureDeclaration.h
+++ b/ir/ts/tsSignatureDeclaration.h
@@ -45,9 +45,9 @@ public:
         : Expression(AstNodeType::TS_SIGNATURE_DECLARATION),
           scope_(scope),
           kind_(kind),
-          typeParams_(typeParams),
+          type_params_(typeParams),
           params_(std::move(params)),
-          returnTypeAnnotation_(returnTypeAnnotation)
+          return_type_annotation_(returnTypeAnnotation)
     {
     }
     binder::Scope *Scope() const
@@ -57,7 +57,7 @@ public:
 
     const TSTypeParameterDeclaration *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     const ArenaVector<Expression *> &Params() const
@@ -67,7 +67,7 @@ public:
 
     const Expression *ReturnTypeAnnotation() const
     {
-        return returnTypeAnnotation_;
+        return return_type_annotation_;
     }
 
     TSSignatureDeclarationKind Kind() const
@@ -83,9 +83,9 @@ public:
 private:
     binder::Scope *scope_;
     TSSignatureDeclarationKind kind_;
-    TSTypeParameterDeclaration *typeParams_;
+    TSTypeParameterDeclaration *type_params_;
     ArenaVector<Expression *> params_;
-    Expression *returnTypeAnnotation_;
+    Expression *return_type_annotation_;
 };
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsTupleType.cpp b/ir/ts/tsTupleType.cpp
index fb835d731eb08f9b4f39cb4fdd3ed9c2680d6ea1..2ae30eedba8bb9cdd249e6b7dcc1cc11e6bfafd5 100644
--- a/ir/ts/tsTupleType.cpp
+++ b/ir/ts/tsTupleType.cpp
@@ -27,14 +27,14 @@ namespace panda::es2panda::ir {
 
 void TSTupleType::Iterate(const NodeTraverser &cb) const
 {
-    for (auto *it : elementTypes_) {
+    for (auto *it : element_types_) {
         cb(it);
     }
 }
 
 void TSTupleType::Dump(ir::AstDumper *dumper) const
 {
-    dumper->Add({{"type", "TSTupleType"}, {"elementTypes", elementTypes_}});
+    dumper->Add({{"type", "TSTupleType"}, {"elementTypes", element_types_}});
 }
 
 void TSTupleType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
@@ -48,7 +48,7 @@ checker::Type *TSTupleType::Check(checker::Checker *checker) const
     uint32_t minLength = 0;
     uint32_t index = 0;
     std::vector<checker::Type *> numberIndexTypes;
-    for (auto *it : elementTypes_) {
+    for (auto *it : element_types_) {
         util::StringView memberIndex = util::Helpers::ToStringView(checker->Allocator(), index);
 
         auto *memberVar =
@@ -83,11 +83,11 @@ checker::Type *TSTupleType::Check(checker::Checker *checker) const
         combinedFlags |= memberFlag;
 
         elementFlags.insert({memberIndex, memberFlag});
-        desc->properties.push_back(memberVar);
+        desc->properties_.push_back(memberVar);
         index++;
     }
 
-    uint32_t fixedLength = desc->properties.size();
+    uint32_t fixedLength = desc->properties_.size();
 
     checker::Type *numberIndexType = nullptr;
 
@@ -99,7 +99,7 @@ checker::Type *TSTupleType::Check(checker::Checker *checker) const
         numberIndexType = checker->CreateUnionType(std::move(numberIndexTypes));
     }
 
-    desc->numberIndexInfo = checker->Allocator()->New<checker::IndexInfo>(numberIndexType, "x");
+    desc->number_index_info_ = checker->Allocator()->New<checker::IndexInfo>(numberIndexType, "x");
 
     return checker->CreateTupleType(desc, std::move(elementFlags), combinedFlags, minLength, fixedLength, false,
                                     std::move(namedMembers));
diff --git a/ir/ts/tsTupleType.h b/ir/ts/tsTupleType.h
index 6e7adec0796b5f5cc08db0b6132903604547f42b..e488d827c835c54c0927ad4462dc045b7e25ee1d 100644
--- a/ir/ts/tsTupleType.h
+++ b/ir/ts/tsTupleType.h
@@ -34,13 +34,13 @@ enum class TSTupleKind { NONE, NAMED, DEFAULT };
 class TSTupleType : public Expression {
 public:
     explicit TSTupleType(ArenaVector<Expression *> &&elementTypes)
-        : Expression(AstNodeType::TS_TUPLE_TYPE), elementTypes_(std::move(elementTypes))
+        : Expression(AstNodeType::TS_TUPLE_TYPE), element_types_(std::move(elementTypes))
     {
     }
 
     const ArenaVector<Expression *> &ElementType() const
     {
-        return elementTypes_;
+        return element_types_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -49,7 +49,7 @@ public:
     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
 
 private:
-    ArenaVector<Expression *> elementTypes_;
+    ArenaVector<Expression *> element_types_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsTypeAliasDeclaration.cpp b/ir/ts/tsTypeAliasDeclaration.cpp
index 48b95901e2fb7a8f631f70342f7bfa84ae6f8d5b..c60dbb0b29a099f677b127ba5597a07811646348 100644
--- a/ir/ts/tsTypeAliasDeclaration.cpp
+++ b/ir/ts/tsTypeAliasDeclaration.cpp
@@ -28,19 +28,19 @@ void TSTypeAliasDeclaration::Iterate(const NodeTraverser &cb) const
 {
     cb(id_);
 
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
-    cb(typeAnnotation_);
+    cb(type_annotation_);
 }
 
 void TSTypeAliasDeclaration::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TSTypeAliasDeclaration"},
                  {"id", id_},
-                 {"typeAnnotation", typeAnnotation_},
-                 {"typeParameters", AstDumper::Optional(typeParams_)},
+                 {"typeAnnotation", type_annotation_},
+                 {"typeParameters", AstDumper::Optional(type_params_)},
                  {"declare", AstDumper::Optional(declare_)}});
 }
 
@@ -49,7 +49,7 @@ void TSTypeAliasDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) co
 checker::Type *TSTypeAliasDeclaration::CheckTypeAnnotation(checker::Checker *checker,
                                                            binder::Variable *bindingVar) const
 {
-    checker::Type *aliasType = typeAnnotation_->Check(checker);
+    checker::Type *aliasType = type_annotation_->Check(checker);
     aliasType->SetVariable(bindingVar);
     bindingVar->SetTsType(aliasType);
 
@@ -58,9 +58,9 @@ checker::Type *TSTypeAliasDeclaration::CheckTypeAnnotation(checker::Checker *che
 
 checker::Type *TSTypeAliasDeclaration::InferType(checker::Checker *checker, binder::Variable *bindingVar) const
 {
-    if (typeParams_) {
-        checker::ScopeContext scopeCtx(checker, typeParams_->Scope());
-        checker->CheckTypeParameters(typeParams_);
+    if (type_params_) {
+        checker::ScopeContext scopeCtx(checker, type_params_->Scope());
+        checker->CheckTypeParameters(type_params_);
         return CheckTypeAnnotation(checker, bindingVar);
     }
 
@@ -71,10 +71,10 @@ checker::Type *TSTypeAliasDeclaration::Check([[maybe_unused]] checker::Checker *
 {
     const util::StringView &aliasName = id_->Name();
     binder::ScopeFindResult result = checker->Scope()->Find(aliasName);
-    ASSERT(result.variable);
+    ASSERT(result.variable_);
 
-    if (!result.variable->TsType()) {
-        InferType(checker, result.variable);
+    if (!result.variable_->TsType()) {
+        InferType(checker, result.variable_);
     }
 
     return nullptr;
diff --git a/ir/ts/tsTypeAliasDeclaration.h b/ir/ts/tsTypeAliasDeclaration.h
index f882d51491ad3140682a4f240c06c1169ae877c3..f0976c638135b67993b694e98537c58bbf14a996 100644
--- a/ir/ts/tsTypeAliasDeclaration.h
+++ b/ir/ts/tsTypeAliasDeclaration.h
@@ -42,8 +42,8 @@ public:
                                     bool declare)
         : Statement(AstNodeType::TS_TYPE_ALIAS_DECLARATION),
           id_(id),
-          typeParams_(typeParams),
-          typeAnnotation_(typeAnnotation),
+          type_params_(typeParams),
+          type_annotation_(typeAnnotation),
           declare_(declare)
     {
     }
@@ -55,12 +55,12 @@ public:
 
     const TSTypeParameterDeclaration *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     bool Declare() const
@@ -78,8 +78,8 @@ private:
     checker::Type *CheckTypeAnnotation(checker::Checker *checker, binder::Variable *bindingVar) const;
 
     Identifier *id_;
-    TSTypeParameterDeclaration *typeParams_;
-    Expression *typeAnnotation_;
+    TSTypeParameterDeclaration *type_params_;
+    Expression *type_annotation_;
     bool declare_;
 };
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsTypeAssertion.cpp b/ir/ts/tsTypeAssertion.cpp
index 90ed300678e3ac304d9615a42eb94d2c4a440f2f..216bdd5a33c7d27eebee9ba8c498be9026e59c5c 100644
--- a/ir/ts/tsTypeAssertion.cpp
+++ b/ir/ts/tsTypeAssertion.cpp
@@ -21,13 +21,13 @@ namespace panda::es2panda::ir {
 
 void TSTypeAssertion::Iterate(const NodeTraverser &cb) const
 {
-    cb(typeAnnotation_);
+    cb(type_annotation_);
     cb(expression_);
 }
 
 void TSTypeAssertion::Dump(ir::AstDumper *dumper) const
 {
-    dumper->Add({{"type", "TSTypeAssertion"}, {"typeAnnotation", typeAnnotation_}, {"expression", expression_}});
+    dumper->Add({{"type", "TSTypeAssertion"}, {"typeAnnotation", type_annotation_}, {"expression", expression_}});
 }
 
 void TSTypeAssertion::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
diff --git a/ir/ts/tsTypeAssertion.h b/ir/ts/tsTypeAssertion.h
index d23ba49630adf3e0007e682d4733cdcd405898f9..ac3a1c7bd40e55bd60a78704bfa7cd1a290554fd 100644
--- a/ir/ts/tsTypeAssertion.h
+++ b/ir/ts/tsTypeAssertion.h
@@ -32,13 +32,13 @@ namespace panda::es2panda::ir {
 class TSTypeAssertion : public Expression {
 public:
     explicit TSTypeAssertion(Expression *typeAnnotation, Expression *expression)
-        : Expression(AstNodeType::TS_TYPE_ASSERTION), typeAnnotation_(typeAnnotation), expression_(expression)
+        : Expression(AstNodeType::TS_TYPE_ASSERTION), type_annotation_(typeAnnotation), expression_(expression)
     {
     }
 
     const Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     const Expression *GetExpression() const
@@ -52,7 +52,7 @@ public:
     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
 
 private:
-    Expression *typeAnnotation_;
+    Expression *type_annotation_;
     Expression *expression_;
 };
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsTypeOperator.cpp b/ir/ts/tsTypeOperator.cpp
index bd17dba1a2ec89064d61449d2c276a26aa3fe702..7dcd3286170c30c7fa3d0ca372693525b4992dbe 100644
--- a/ir/ts/tsTypeOperator.cpp
+++ b/ir/ts/tsTypeOperator.cpp
@@ -28,7 +28,7 @@ void TSTypeOperator::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({
         {"type", "TSTypeOperator"},
-        {"operator", AstDumper::TypeOperatorToString(operatorType_)},
+        {"operator", AstDumper::TypeOperatorToString(operator_type_)},
         {"typeAnnotation", type_},
     });
 }
diff --git a/ir/ts/tsTypeOperator.h b/ir/ts/tsTypeOperator.h
index 8cbefb6332ea528f4f376304a4bf7a59990a76d6..01aad3a6c1e1243e75c0e8a6ab5ad156c84aa4c2 100644
--- a/ir/ts/tsTypeOperator.h
+++ b/ir/ts/tsTypeOperator.h
@@ -32,7 +32,7 @@ namespace panda::es2panda::ir {
 class TSTypeOperator : public Expression {
 public:
     explicit TSTypeOperator(Expression *type, TSOperatorType operatorType)
-        : Expression(AstNodeType::TS_TYPE_OPERATOR), type_(type), operatorType_(operatorType)
+        : Expression(AstNodeType::TS_TYPE_OPERATOR), type_(type), operator_type_(operatorType)
     {
     }
 
@@ -43,17 +43,17 @@ public:
 
     bool IsReadonly() const
     {
-        return operatorType_ == TSOperatorType::READONLY;
+        return operator_type_ == TSOperatorType::READONLY;
     }
 
     bool IsKeyof() const
     {
-        return operatorType_ == TSOperatorType::KEYOF;
+        return operator_type_ == TSOperatorType::KEYOF;
     }
 
     bool IsUnique() const
     {
-        return operatorType_ == TSOperatorType::UNIQUE;
+        return operator_type_ == TSOperatorType::UNIQUE;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -63,7 +63,7 @@ public:
 
 private:
     Expression *type_;
-    TSOperatorType operatorType_;
+    TSOperatorType operator_type_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsTypeParameter.cpp b/ir/ts/tsTypeParameter.cpp
index 462c53bb2e81664243f11010fbedcdca7c7dde3e..33e47722d0855f59aaddae4fdce1c6cc40e8ec9d 100644
--- a/ir/ts/tsTypeParameter.cpp
+++ b/ir/ts/tsTypeParameter.cpp
@@ -28,8 +28,8 @@ void TSTypeParameter::Iterate(const NodeTraverser &cb) const
         cb(constraint_);
     }
 
-    if (defaultType_) {
-        cb(defaultType_);
+    if (default_type_) {
+        cb(default_type_);
     }
 }
 
@@ -39,7 +39,7 @@ void TSTypeParameter::Dump(ir::AstDumper *dumper) const
         {"type", "TSTypeParameter"},
         {"name", name_},
         {"constraint", AstDumper::Optional(constraint_)},
-        {"default", AstDumper::Optional(defaultType_)},
+        {"default", AstDumper::Optional(default_type_)},
     });
 }
 
diff --git a/ir/ts/tsTypeParameter.h b/ir/ts/tsTypeParameter.h
index fb6d2c0331bb61a4a20e27721e09a1193941d520..845e3157b5395b0a4f45a59f6bc410a9c4566d50 100644
--- a/ir/ts/tsTypeParameter.h
+++ b/ir/ts/tsTypeParameter.h
@@ -34,7 +34,7 @@ class Identifier;
 class TSTypeParameter : public Expression {
 public:
     explicit TSTypeParameter(Identifier *name, Expression *constraint, Expression *defaultType)
-        : Expression(AstNodeType::TS_TYPE_PARAMETER), name_(name), constraint_(constraint), defaultType_(defaultType)
+        : Expression(AstNodeType::TS_TYPE_PARAMETER), name_(name), constraint_(constraint), default_type_(defaultType)
     {
     }
 
@@ -50,7 +50,7 @@ public:
 
     const Expression *DefaultType() const
     {
-        return defaultType_;
+        return default_type_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -61,7 +61,7 @@ public:
 private:
     Identifier *name_;
     Expression *constraint_;
-    Expression *defaultType_;
+    Expression *default_type_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsTypeParameterDeclaration.h b/ir/ts/tsTypeParameterDeclaration.h
index d8b09540b6bbc9e2dbcda5c76e6d883357620922..a090ef2822859437860c315897ebce49f488772c 100644
--- a/ir/ts/tsTypeParameterDeclaration.h
+++ b/ir/ts/tsTypeParameterDeclaration.h
@@ -42,7 +42,7 @@ public:
         : Expression(AstNodeType::TS_TYPE_PARAMETER_DECLARATION),
           scope_(scope),
           params_(std::move(params)),
-          requiredParams_(requiredParams)
+          required_params_(requiredParams)
     {
     }
 
@@ -58,7 +58,7 @@ public:
 
     size_t RequiredParams() const
     {
-        return requiredParams_;
+        return required_params_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -69,7 +69,7 @@ public:
 private:
     binder::LocalScope *scope_;
     ArenaVector<TSTypeParameter *> params_;
-    size_t requiredParams_;
+    size_t required_params_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsTypePredicate.cpp b/ir/ts/tsTypePredicate.cpp
index d5cd205ec9a88490fd97b3724d58e0e1a38a376d..61cb4f25286902adf8b566ba5e6f0516ebf49b63 100644
--- a/ir/ts/tsTypePredicate.cpp
+++ b/ir/ts/tsTypePredicate.cpp
@@ -22,17 +22,17 @@ namespace panda::es2panda::ir {
 
 void TSTypePredicate::Iterate(const NodeTraverser &cb) const
 {
-    cb(parameterName_);
-    if (typeAnnotation_) {
-        cb(typeAnnotation_);
+    cb(parameter_name_);
+    if (type_annotation_) {
+        cb(type_annotation_);
     }
 }
 
 void TSTypePredicate::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add({{"type", "TSTypePredicate"},
-                 {"parameterName", parameterName_},
-                 {"typeAnnotation", AstDumper::Nullable(typeAnnotation_)},
+                 {"parameterName", parameter_name_},
+                 {"typeAnnotation", AstDumper::Nullable(type_annotation_)},
                  {"asserts", asserts_}});
 }
 
diff --git a/ir/ts/tsTypePredicate.h b/ir/ts/tsTypePredicate.h
index 3ebc93222003b7e6d45a6c7827b34e5c3d50daf2..f7b68ad10a34bdde2a35e6c4bc84eaf781ace322 100644
--- a/ir/ts/tsTypePredicate.h
+++ b/ir/ts/tsTypePredicate.h
@@ -33,20 +33,20 @@ class TSTypePredicate : public Expression {
 public:
     explicit TSTypePredicate(Expression *parameterName, Expression *typeAnnotation, bool asserts)
         : Expression(AstNodeType::TS_TYPE_PREDICATE),
-          parameterName_(parameterName),
-          typeAnnotation_(typeAnnotation),
+          parameter_name_(parameterName),
+          type_annotation_(typeAnnotation),
           asserts_(asserts)
     {
     }
 
     Expression *ParameterName() const
     {
-        return parameterName_;
+        return parameter_name_;
     }
 
     Expression *TypeAnnotation() const
     {
-        return typeAnnotation_;
+        return type_annotation_;
     }
 
     bool Asserts() const
@@ -60,8 +60,8 @@ public:
     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
 
 private:
-    Expression *parameterName_;
-    Expression *typeAnnotation_;
+    Expression *parameter_name_;
+    Expression *type_annotation_;
     bool asserts_;
 };
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsTypeQuery.cpp b/ir/ts/tsTypeQuery.cpp
index 917bfedbb2d027b6670b1a1d87762cd8daf51654..593f63719b9907030b894d7fda6199219783c11e 100644
--- a/ir/ts/tsTypeQuery.cpp
+++ b/ir/ts/tsTypeQuery.cpp
@@ -21,20 +21,20 @@ namespace panda::es2panda::ir {
 
 void TSTypeQuery::Iterate(const NodeTraverser &cb) const
 {
-    cb(exprName_);
+    cb(expr_name_);
 }
 
 void TSTypeQuery::Dump(ir::AstDumper *dumper) const
 {
-    dumper->Add({{"type", "TSTypeQuery"}, {"exprName", exprName_}});
+    dumper->Add({{"type", "TSTypeQuery"}, {"exprName", expr_name_}});
 }
 
 void TSTypeQuery::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
 
 checker::Type *TSTypeQuery::Check([[maybe_unused]] checker::Checker *checker) const
 {
-    ASSERT(exprName_->IsIdentifier() || exprName_->IsTSQualifiedName());
-    return exprName_->Check(checker);
+    ASSERT(expr_name_->IsIdentifier() || expr_name_->IsTSQualifiedName());
+    return expr_name_->Check(checker);
 }
 
 }  // namespace panda::es2panda::ir
diff --git a/ir/ts/tsTypeQuery.h b/ir/ts/tsTypeQuery.h
index 060a2c1bbe7dc66171521fca7ebbe01484a3619b..8a5f9343f1fc7a18a22debd1b0341f7d39f68d1d 100644
--- a/ir/ts/tsTypeQuery.h
+++ b/ir/ts/tsTypeQuery.h
@@ -31,11 +31,11 @@ namespace panda::es2panda::ir {
 
 class TSTypeQuery : public Expression {
 public:
-    explicit TSTypeQuery(Expression *exprName) : Expression(AstNodeType::TS_TYPE_QUERY), exprName_(exprName) {}
+    explicit TSTypeQuery(Expression *exprName) : Expression(AstNodeType::TS_TYPE_QUERY), expr_name_(exprName) {}
 
     const Expression *ExprName() const
     {
-        return exprName_;
+        return expr_name_;
     }
 
     void Iterate(const NodeTraverser &cb) const override;
@@ -44,7 +44,7 @@ public:
     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
 
 private:
-    Expression *exprName_;
+    Expression *expr_name_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/ts/tsTypeReference.cpp b/ir/ts/tsTypeReference.cpp
index 85859524242d492f76b62897d9b5ce529290b812..6507829b973b06ed4661ff098fd7fe88ebfc93e9 100644
--- a/ir/ts/tsTypeReference.cpp
+++ b/ir/ts/tsTypeReference.cpp
@@ -30,29 +30,30 @@ namespace panda::es2panda::ir {
 
 void TSTypeReference::Iterate(const NodeTraverser &cb) const
 {
-    if (typeParams_) {
-        cb(typeParams_);
+    if (type_params_) {
+        cb(type_params_);
     }
 
-    cb(typeName_);
+    cb(type_name_);
 }
 
 void TSTypeReference::Dump(ir::AstDumper *dumper) const
 {
     dumper->Add(
-        {{"type", "TSTypeReference"}, {"typeName", typeName_}, {"typeParameters", AstDumper::Optional(typeParams_)}});
+        {{"type", "TSTypeReference"}, {"typeName", type_name_}, {"typeParameters", AstDumper::Optional(type_params_)}});
 }
 
 void TSTypeReference::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
 
 checker::Type *TSTypeReference::Check([[maybe_unused]] checker::Checker *checker) const
 {
-    if (typeName_->IsIdentifier()) {
-        return ResolveReference(checker, typeName_->AsIdentifier()->Variable(), typeName_->AsIdentifier(), typeParams_);
+    if (type_name_->IsIdentifier()) {
+        return ResolveReference(checker, type_name_->AsIdentifier()->Variable(), type_name_->AsIdentifier(),
+                                type_params_);
     }
 
-    ASSERT(typeName_->IsTSQualifiedName());
-    return typeName_->Check(checker);
+    ASSERT(type_name_->IsTSQualifiedName());
+    return type_name_->Check(checker);
 }
 
 checker::Type *TSTypeReference::ResolveReference(checker::Checker *checker, binder::Variable *var,
diff --git a/ir/ts/tsTypeReference.h b/ir/ts/tsTypeReference.h
index 40f024a24c46ea5c1b1337510a30c900ed34f8c9..7c97ed13a333d4a05598a64887c0afba0d2aabf7 100644
--- a/ir/ts/tsTypeReference.h
+++ b/ir/ts/tsTypeReference.h
@@ -39,18 +39,18 @@ class TSTypeParameterInstantiation;
 class TSTypeReference : public Expression {
 public:
     explicit TSTypeReference(Expression *typeName, TSTypeParameterInstantiation *typeParams)
-        : Expression(AstNodeType::TS_TYPE_REFERENCE), typeName_(typeName), typeParams_(typeParams)
+        : Expression(AstNodeType::TS_TYPE_REFERENCE), type_name_(typeName), type_params_(typeParams)
     {
     }
 
     const TSTypeParameterInstantiation *TypeParams() const
     {
-        return typeParams_;
+        return type_params_;
     }
 
     const Expression *TypeName() const
     {
-        return typeName_;
+        return type_name_;
     }
 
     static checker::Type *ResolveReference(checker::Checker *checker, binder::Variable *var,
@@ -63,8 +63,8 @@ public:
     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
 
 private:
-    Expression *typeName_;
-    TSTypeParameterInstantiation *typeParams_;
+    Expression *type_name_;
+    TSTypeParameterInstantiation *type_params_;
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/ir/validationInfo.h b/ir/validationInfo.h
index 26b0446739500dbf7fb142ed38d369bec069d7be..d8ba9dbb6dd687886afb6ec90b11787d774ef3d0 100644
--- a/ir/validationInfo.h
+++ b/ir/validationInfo.h
@@ -23,15 +23,15 @@ namespace panda::es2panda::ir {
 class ValidationInfo {
 public:
     ValidationInfo() noexcept = default;
-    ValidationInfo(util::StringView m, lexer::SourcePosition p) noexcept : msg(m), pos(p) {}
+    ValidationInfo(util::StringView m, lexer::SourcePosition p) noexcept : msg_(m), pos_(p) {}
 
     inline bool Fail() const
     {
-        return !msg.Empty();
+        return !msg_.Empty();
     }
 
-    util::StringView msg {};
-    lexer::SourcePosition pos {};
+    util::StringView msg_ {};
+    lexer::SourcePosition pos_ {};
 };
 }  // namespace panda::es2panda::ir
 
diff --git a/lexer/keywordString.h b/lexer/keywordString.h
index fcc8c13590fb01a808cb0c2c0a78f003c169dfef..24ec525306216e2c86979187c84faa1e7029ad0a 100644
--- a/lexer/keywordString.h
+++ b/lexer/keywordString.h
@@ -23,13 +23,13 @@
 namespace panda::es2panda::lexer {
 
 struct KeywordString {
-    constexpr KeywordString(std::string_view s, TokenType t, TokenType k) : str(s), tokenType(t), keywordType(k) {}
+    constexpr KeywordString(std::string_view s, TokenType t, TokenType k) : str_(s), token_type_(t), keyword_type_(k) {}
 
-    explicit KeywordString(std::string_view &s) : str(s) {}
+    explicit KeywordString(std::string_view &s) : str_(s) {}
 
-    std::string_view str;
-    TokenType tokenType {};
-    TokenType keywordType {};
+    std::string_view str_;
+    TokenType token_type_ {};
+    TokenType keyword_type_ {};
 };
 
 }  // namespace panda::es2panda::lexer
diff --git a/lexer/keywordsUtil.cpp b/lexer/keywordsUtil.cpp
index 452a122f82fbad5947d1bb8963524b6922849ff5..618abffcde884a1960f84784a1f1871a19e210f8 100644
--- a/lexer/keywordsUtil.cpp
+++ b/lexer/keywordsUtil.cpp
@@ -207,7 +207,7 @@ void KeywordsUtil::ScanIdentifierStart(char32_t cp)
 void KeywordsUtil::ScanIdContinue()
 {
     util::UString ident(lexer_->Allocator());
-    size_t startPos = lexer_->GetToken().Start().index;
+    size_t startPos = lexer_->GetToken().Start().index_;
 
     if (HasEscape()) {
         ident.Append(cp_);
@@ -240,7 +240,7 @@ void KeywordsUtil::ScanIdContinue()
     } while (true);
 
     lexer_->GetToken().type_ = TokenType::LITERAL_IDENT;
-    lexer_->GetToken().keywordType_ = TokenType::EOS;
+    lexer_->GetToken().keyword_type_ = TokenType::EOS;
 
     if (HasEscape()) {
         ident.Append(lexer_->SourceView(escapeEnd, Iterator().Index()));
@@ -267,7 +267,7 @@ void KeywordsUtil::ScanIdContinueMaybeKeyword(Span<const KeywordString> map)
     while (true) {
         const auto &kws = map[middle];
 
-        int relation = str.compare(kws.str);
+        int relation = str.compare(kws.str_);
         if (relation == 0) {
             Keywords::SetKeyword(this, kws);
         }
diff --git a/lexer/keywordsUtil.h b/lexer/keywordsUtil.h
index 245a6ddbc3b50890ccf3a42637d3640851899685..321d2e00794940d0e1d1d9ffb8a5571d8ad1f591 100644
--- a/lexer/keywordsUtil.h
+++ b/lexer/keywordsUtil.h
@@ -72,7 +72,7 @@ inline void KeywordsUtil::SetKeyword(std::string_view str, TokenType type)
 {
     lexer_->GetToken().src_ = util::StringView(str);
     // NOLINTNEXTLINE
-    lexer_->GetToken().keywordType_ = keyword_type;
+    lexer_->GetToken().keyword_type_ = keyword_type;
 
     if (flags_ & lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT) {
         lexer_->GetToken().type_ = TokenType::LITERAL_IDENT;
diff --git a/lexer/lexer.cpp b/lexer/lexer.cpp
index 880527188e5aa9296a1ee95482f6557810e2b1d1..4bc555df3351d6cdec466dec469d3cac9767a185 100644
--- a/lexer/lexer.cpp
+++ b/lexer/lexer.cpp
@@ -25,11 +25,11 @@
 
 namespace panda::es2panda::lexer {
 
-LexerPosition::LexerPosition(const util::StringView &source) : iterator(source) {}
+LexerPosition::LexerPosition(const util::StringView &source) : iterator_(source) {}
 
 Lexer::Lexer(const parser::ParserContext *parserContext)
     : allocator_(parserContext->GetProgram()->Allocator()),
-      parserContext_(parserContext),
+      parser_context_(parserContext),
       source_(parserContext->GetProgram()->SourceCode()),
       pos_(source_)
 {
@@ -85,17 +85,17 @@ ArenaAllocator *Lexer::Allocator()
 
 Token &Lexer::GetToken()
 {
-    return pos_.token;
+    return pos_.token_;
 }
 
 const Token &Lexer::GetToken() const
 {
-    return pos_.token;
+    return pos_.token_;
 }
 
 size_t Lexer::Line() const
 {
-    return pos_.line;
+    return pos_.line_;
 }
 
 LexerPosition Lexer::Save() const
@@ -105,15 +105,15 @@ LexerPosition Lexer::Save() const
 
 void Lexer::BackwardToken(TokenType type, size_t offset)
 {
-    pos_.token.type_ = type;
-    pos_.iterator.Reset(GetToken().End().index - offset);
-    pos_.nextTokenLine = 0;
+    pos_.token_.type_ = type;
+    pos_.iterator_.Reset(GetToken().End().index_ - offset);
+    pos_.next_token_line_ = 0;
 }
 
 void Lexer::ForwardToken(TokenType type, size_t offset)
 {
-    pos_.token.type_ = type;
-    pos_.iterator.Forward(offset);
+    pos_.token_.type_ = type;
+    pos_.iterator_.Forward(offset);
     SkipWhiteSpaces();
 }
 
@@ -149,7 +149,7 @@ void Lexer::SkipMultiLineComment()
             case LEX_CHAR_CR:
             case LEX_CHAR_LS:
             case LEX_CHAR_PS: {
-                pos_.nextTokenLine++;
+                pos_.next_token_line_++;
                 continue;
             }
             case LEX_CHAR_ASTERISK: {
@@ -183,7 +183,7 @@ void Lexer::SkipSingleLineComment()
             case LEX_CHAR_LF:
             case LEX_CHAR_LS:
             case LEX_CHAR_PS: {
-                pos_.nextTokenLine++;
+                pos_.next_token_line_++;
                 return;
             }
             default: {
@@ -195,7 +195,7 @@ void Lexer::SkipSingleLineComment()
 
 void Lexer::ThrowError(std::string_view message)
 {
-    throw es2panda::Error(es2panda::ErrorType::SYNTAX, message, pos_.line, Iterator().Index());
+    throw es2panda::Error(es2panda::ErrorType::SYNTAX, message, pos_.line_, Iterator().Index());
 }
 
 void Lexer::CheckNumberLiteralEnd()
@@ -205,7 +205,7 @@ void Lexer::CheckNumberLiteralEnd()
         GetToken().flags_ |= TokenFlags::NUMBER_BIGINT;
     }
 
-    GetToken().src_ = SourceView(GetToken().Start().index, Iterator().Index());
+    GetToken().src_ = SourceView(GetToken().Start().index_, Iterator().Index());
     const auto nextCp = Iterator().PeekCp();
     if (KeywordsUtil::IsIdentifierStart(nextCp) || IsDecimalDigit(nextCp)) {
         ThrowError("Invalid numeric literal");
@@ -321,7 +321,7 @@ void Lexer::ScanDecimalNumbers(bool allowNumericSeparator)
 
 void Lexer::ConvertNumber(size_t exponentSignPos)
 {
-    util::StringView sv = SourceView(GetToken().Start().index, Iterator().Index());
+    util::StringView sv = SourceView(GetToken().Start().index_, Iterator().Index());
     std::string utf8 = std::string {sv.Utf8()};
     bool needConversion = false;
 
@@ -393,7 +393,7 @@ void Lexer::ScanNumber(bool allowNumericSeparator, bool allowBigInt)
                     break;
                 }
                 default: {
-                    exponentSignPos = Iterator().Index() - GetToken().Start().index;
+                    exponentSignPos = Iterator().Index() - GetToken().Start().index_;
                     break;
                 }
             }
@@ -424,7 +424,7 @@ void Lexer::ScanNumber(bool allowNumericSeparator, bool allowBigInt)
 
 void Lexer::PushTemplateContext(TemplateLiteralParserContext *ctx)
 {
-    tlCtx_ = ctx;
+    tl_ctx_ = ctx;
 }
 
 void Lexer::ScanTemplateStringEnd()
@@ -449,7 +449,7 @@ LexerTemplateString Lexer::ScanTemplateString()
                 break;
             }
             case LEX_CHAR_BACK_TICK: {
-                templateStr.end = Iterator().Index();
+                templateStr.end_ = Iterator().Index();
                 return templateStr;
             }
             case LEX_CHAR_CR: {
@@ -462,8 +462,8 @@ LexerTemplateString Lexer::ScanTemplateString()
                 [[fallthrough]];
             }
             case LEX_CHAR_LF: {
-                pos_.line++;
-                templateStr.str.Append(LEX_CHAR_LF);
+                pos_.line_++;
+                templateStr.str_.Append(LEX_CHAR_LF);
                 Iterator().Forward(1);
                 continue;
             }
@@ -482,8 +482,8 @@ LexerTemplateString Lexer::ScanTemplateString()
                 }
 
                 if (nextCp == LEX_CHAR_BACK_TICK || nextCp == LEX_CHAR_BACKSLASH) {
-                    templateStr.str.Append(cp);
-                    templateStr.str.Append(nextCp);
+                    templateStr.str_.Append(cp);
+                    templateStr.str_.Append(nextCp);
                     Iterator().Forward(1);
                     continue;
                 }
@@ -492,17 +492,17 @@ LexerTemplateString Lexer::ScanTemplateString()
                 break;
             }
             case LEX_CHAR_DOLLAR_SIGN: {
-                templateStr.end = Iterator().Index();
+                templateStr.end_ = Iterator().Index();
                 Iterator().Forward(1);
 
                 if (Iterator().Peek() == LEX_CHAR_LEFT_BRACE) {
                     Iterator().Forward(1);
-                    templateStr.scanExpression = true;
+                    templateStr.scan_expression_ = true;
                     SkipWhiteSpaces();
                     return templateStr;
                 }
 
-                templateStr.str.Append(cp);
+                templateStr.str_.Append(cp);
                 continue;
             }
             default: {
@@ -510,7 +510,7 @@ LexerTemplateString Lexer::ScanTemplateString()
             }
         }
 
-        templateStr.str.Append(cp);
+        templateStr.str_.Append(cp);
         Iterator().Forward(cpSize);
     }
 
@@ -521,9 +521,9 @@ LexerTemplateString Lexer::ScanTemplateString()
 void Lexer::ResetTokenEnd()
 {
     SetTokenStart();
-    pos_.iterator.Reset(GetToken().End().index);
-    pos_.line = GetToken().End().line;
-    pos_.nextTokenLine = 0;
+    pos_.iterator_.Reset(GetToken().End().index_);
+    pos_.line_ = GetToken().End().line_;
+    pos_.next_token_line_ = 0;
 }
 
 void Lexer::ScanStringUnicodePart(util::UString *str)
@@ -547,7 +547,7 @@ void Lexer::ScanStringUnicodePart(util::UString *str)
         case LEX_CHAR_LS:
         case LEX_CHAR_PS:
         case LEX_CHAR_LF: {
-            pos_.line++;
+            pos_.line_++;
             Iterator().Forward(cpSize);
             return;
         }
@@ -1144,30 +1144,30 @@ bool Lexer::CheckArrow()
 
 void Lexer::SetTokenStart()
 {
-    if (pos_.nextTokenLine != 0) {
-        pos_.line += pos_.nextTokenLine;
-        pos_.nextTokenLine = 0;
+    if (pos_.next_token_line_ != 0) {
+        pos_.line_ += pos_.next_token_line_;
+        pos_.next_token_line_ = 0;
         GetToken().flags_ = TokenFlags::NEW_LINE;
     } else {
         GetToken().flags_ = TokenFlags::NONE;
     }
 
-    pos_.token.loc_.start = SourcePosition {Iterator().Index(), pos_.line};
+    pos_.token_.loc_.start_ = SourcePosition {Iterator().Index(), pos_.line_};
 }
 
 void Lexer::SetTokenEnd()
 {
-    pos_.token.loc_.end = SourcePosition {Iterator().Index(), pos_.line};
+    pos_.token_.loc_.end_ = SourcePosition {Iterator().Index(), pos_.line_};
 }
 
 void Lexer::CheckAwaitKeyword()
 {
-    if (!parserContext_->IsAsync()) {
+    if (!parser_context_->IsAsync()) {
         GetToken().type_ = TokenType::LITERAL_IDENT;
         return;
     }
 
-    if (parserContext_->DisallowAwait()) {
+    if (parser_context_->DisallowAwait()) {
         ThrowError("'await' is not allowed");
     }
 
@@ -1185,7 +1185,7 @@ void Lexer::CheckKeywordEscape(TokenType type)
 
 void Lexer::CheckEnumKeyword()
 {
-    if (parserContext_->GetProgram()->Extension() == ScriptExtension::JS) {
+    if (parser_context_->GetProgram()->Extension() == ScriptExtension::JS) {
         ThrowError("Unexpected reserved keyword");
     }
 
@@ -1203,7 +1203,7 @@ void Lexer::CheckLetKeyword()
 
 void Lexer::CheckYieldKeyword()
 {
-    if (!parserContext_->AllowYield()) {
+    if (!parser_context_->AllowYield()) {
         ThrowError("'yield' is not allowed");
     }
 
@@ -1214,7 +1214,7 @@ void Lexer::CheckFutureReservedKeyword(TokenType keywordType)
 {
     GetToken().type_ = TokenType::LITERAL_IDENT;
 
-    if (parserContext_->GetProgram()->Extension() == ScriptExtension::TS && keywordType <= TokenType::KEYW_INTERFACE) {
+    if (parser_context_->GetProgram()->Extension() == ScriptExtension::TS && keywordType <= TokenType::KEYW_INTERFACE) {
         return;
     }
 
@@ -1238,7 +1238,7 @@ void Lexer::SkipWhiteSpaces()
             }
             case LEX_CHAR_LF: {
                 Iterator().Forward(1);
-                pos_.nextTokenLine++;
+                pos_.next_token_line_++;
                 continue;
             }
             case LEX_CHAR_VT:
@@ -1276,7 +1276,7 @@ void Lexer::SkipWhiteSpaces()
                 switch (cp) {
                     case LEX_CHAR_LS:
                     case LEX_CHAR_PS: {
-                        pos_.nextTokenLine++;
+                        pos_.next_token_line_++;
                         [[fallthrough]];
                     }
                     case LEX_CHAR_NBSP:
@@ -1557,8 +1557,8 @@ void Lexer::NextToken(LexerNextTokenFlags flags)
         case LEX_CHAR_LEFT_BRACE: {
             GetToken().type_ = TokenType::PUNCTUATOR_LEFT_BRACE;
 
-            if (tlCtx_) {
-                tlCtx_->ConsumeLeftBrace();
+            if (tl_ctx_) {
+                tl_ctx_->ConsumeLeftBrace();
             }
 
             break;
@@ -1570,7 +1570,7 @@ void Lexer::NextToken(LexerNextTokenFlags flags)
         case LEX_CHAR_RIGHT_BRACE: {
             GetToken().type_ = TokenType::PUNCTUATOR_RIGHT_BRACE;
 
-            if (tlCtx_ && tlCtx_->ConsumeRightBrace()) {
+            if (tl_ctx_ && tl_ctx_->ConsumeRightBrace()) {
                 SetTokenEnd();
                 return;
             }
diff --git a/lexer/lexer.h b/lexer/lexer.h
index b8302270254e34d7535b8cc14df7819cea242c25..8dd0805b2b9ca188692cadca4c47d3492abe40ca 100644
--- a/lexer/lexer.h
+++ b/lexer/lexer.h
@@ -43,22 +43,22 @@ public:
     DEFAULT_MOVE_SEMANTIC(LexerPosition);
     ~LexerPosition() = default;
 
-    Token token {};
-    util::StringView::Iterator iterator;
-    size_t line {};
-    size_t nextTokenLine {};
+    Token token_ {};
+    util::StringView::Iterator iterator_;
+    size_t line_ {};
+    size_t next_token_line_ {};
 };
 
 class LexerTemplateString {
 public:
-    explicit LexerTemplateString(ArenaAllocator *allocator) : str(allocator) {}
+    explicit LexerTemplateString(ArenaAllocator *allocator) : str_(allocator) {}
     DEFAULT_COPY_SEMANTIC(LexerTemplateString);
     DEFAULT_MOVE_SEMANTIC(LexerTemplateString);
     ~LexerTemplateString() = default;
 
-    util::UString str;
-    size_t end {};
-    bool scanExpression {};
+    util::UString str_;
+    size_t end_ {};
+    bool scan_expression_ {};
 };
 
 class TemplateLiteralParserContext;
@@ -105,12 +105,12 @@ private:
 
     inline util::StringView::Iterator &Iterator()
     {
-        return pos_.iterator;
+        return pos_.iterator_;
     }
 
     inline const util::StringView::Iterator &Iterator() const
     {
-        return pos_.iterator;
+        return pos_.iterator_;
     }
 
     util::StringView SourceView(const util::StringView::Iterator &begin, const util::StringView::Iterator &end) const;
@@ -169,40 +169,40 @@ private:
 
     friend class KeywordsUtil;
     friend class TemplateLiteralParserContext;
-    TemplateLiteralParserContext *tlCtx_ {};
+    TemplateLiteralParserContext *tl_ctx_ {};
     ArenaAllocator *allocator_;
-    const parser::ParserContext *parserContext_;
+    const parser::ParserContext *parser_context_;
     util::StringView source_;
     LexerPosition pos_;
 };
 
 class TemplateLiteralParserContext {
 public:
-    explicit TemplateLiteralParserContext(Lexer *lexer) : lexer_(lexer), prev_(lexer_->tlCtx_) {}
+    explicit TemplateLiteralParserContext(Lexer *lexer) : lexer_(lexer), prev_(lexer_->tl_ctx_) {}
     NO_MOVE_SEMANTIC(TemplateLiteralParserContext);
     NO_COPY_SEMANTIC(TemplateLiteralParserContext);
 
     ~TemplateLiteralParserContext()
     {
-        lexer_->tlCtx_ = prev_;
+        lexer_->tl_ctx_ = prev_;
     }
 
     void ConsumeLeftBrace()
     {
-        braceDepth_++;
+        brace_depth_++;
     }
 
     bool ConsumeRightBrace()
     {
-        braceDepth_--;
+        brace_depth_--;
 
-        return braceDepth_ == 0;
+        return brace_depth_ == 0;
     }
 
 private:
     Lexer *lexer_;
     TemplateLiteralParserContext *prev_ {};
-    size_t braceDepth_ {1};
+    size_t brace_depth_ {1};
 };
 
 template <char32_t end>
@@ -240,7 +240,7 @@ void Lexer::ScanString()
                     }
                 }
 
-                pos_.line++;
+                pos_.line_++;
                 str.Append(LEX_CHAR_LF);
                 Iterator().Forward(1);
                 escapeEnd = Iterator().Index();
diff --git a/lexer/regexp/regexp.cpp b/lexer/regexp/regexp.cpp
index 6140f2940ab13a35c0f49226124cef34a4282353..b571a0edc24726dee7952a4954c6420d1c50d5ce 100644
--- a/lexer/regexp/regexp.cpp
+++ b/lexer/regexp/regexp.cpp
@@ -22,20 +22,21 @@
 
 namespace panda::es2panda::lexer {
 
-RegExpError::RegExpError(std::string_view m) : message(m) {}
+RegExpError::RegExpError(std::string_view m) : message_(m) {}
 
-RegExp::RegExp(util::StringView p, util::StringView f, RegExpFlags reFlags) : patternStr(p), flagsStr(f), flags(reFlags)
+RegExp::RegExp(util::StringView p, util::StringView f, RegExpFlags reFlags)
+    : pattern_str_(p), flags_str_(f), flags_(reFlags)
 {
 }
 
 RegExpParser::RegExpParser(const RegExp &re, ArenaAllocator *allocator)
-    : re_(re), allocator_ {allocator}, iter_(re_.patternStr)
+    : re_(re), allocator_ {allocator}, iter_(re_.pattern_str_)
 {
 }
 
 bool RegExpParser::Unicode() const
 {
-    return (re_.flags & RegExpFlags::UNICODE) != 0;
+    return (re_.flags_ & RegExpFlags::UNICODE) != 0;
 }
 
 char32_t RegExpParser::Peek() const
@@ -228,7 +229,7 @@ void RegExpParser::ParseNamedCapturingGroup()
 {
     util::StringView name = ParseIdent();
 
-    auto result = groupNames_.insert(name);
+    auto result = group_names_.insert(name);
     if (!result.second) {
         ThrowError("Duplicate group name");
     }
@@ -238,7 +239,7 @@ void RegExpParser::ParseNamedCapturingGroup()
 
 void RegExpParser::ParseCapturingGroup()
 {
-    capturingGroupCount_++;
+    capturing_group_count_++;
 
     ParseDisjunction();
 
@@ -536,7 +537,7 @@ uint32_t RegExpParser::ParseDecimalEscape()
         decimalValue = newValue;
     }
 
-    if (decimalValue <= capturingGroupCount_) {
+    if (decimalValue <= capturing_group_count_) {
         return decimalValue;
     }
 
@@ -689,7 +690,7 @@ void RegExpParser::ParseUnicodePropertyEscape()
 
 void RegExpParser::ParseNamedBackreference()
 {
-    if (groupNames_.empty()) {
+    if (group_names_.empty()) {
         /* Identity escape */
         return;
     }
@@ -700,8 +701,8 @@ void RegExpParser::ParseNamedBackreference()
 
     util::StringView name = ParseIdent();
 
-    auto result = groupNames_.find(name);
-    if (result == groupNames_.end()) {
+    auto result = group_names_.find(name);
+    if (result == group_names_.end()) {
         ThrowError("Invalid named capture referenced");
     }
 }
diff --git a/lexer/regexp/regexp.h b/lexer/regexp/regexp.h
index e6a4be21a052bcfede31cc667133316df6c9af6c..4a8379dfa23812b53cbb943704e9a80d27666779 100644
--- a/lexer/regexp/regexp.h
+++ b/lexer/regexp/regexp.h
@@ -38,15 +38,15 @@ DEFINE_BITOPS(RegExpFlags)
 class RegExpError : std::exception {
 public:
     explicit RegExpError(std::string_view m);
-    std::string message;
+    std::string message_;
 };
 
 struct RegExp {
     RegExp(util::StringView p, util::StringView f, RegExpFlags reFlags);
 
-    util::StringView patternStr;
-    util::StringView flagsStr;
-    RegExpFlags flags;
+    util::StringView pattern_str_;
+    util::StringView flags_str_;
+    RegExpFlags flags_;
 };
 
 class RegExpParser {
@@ -96,8 +96,8 @@ private:
     RegExp re_;
     ArenaAllocator *allocator_ {};
     util::StringView::Iterator iter_;
-    uint32_t capturingGroupCount_ {0};
-    std::unordered_set<util::StringView> groupNames_;
+    uint32_t capturing_group_count_ {0};
+    std::unordered_set<util::StringView> group_names_;
 };
 
 }  // namespace panda::es2panda::lexer
diff --git a/lexer/templates/keywords.h.erb b/lexer/templates/keywords.h.erb
index fa2851a2c88289d22c803f556da360a2e926c23e..c6e8e4685db6fb77c58a3ac443a0d730dd7ce5f2 100644
--- a/lexer/templates/keywords.h.erb
+++ b/lexer/templates/keywords.h.erb
@@ -36,11 +36,11 @@ public:
 
     // NOLINTNEXTLINE(readability-function-size)
     static void SetKeyword(KeywordsUtil *util, const KeywordString& kws) {
-        switch(kws.keywordType) {
+        switch(kws.keyword_type_) {
 % keywords.each do |group|
 %   group.each do |key, kw|
         case <%= kw[1] %>: {
-            return util->SetKeyword<<%= kw[1] %>>(kws.str, kws.tokenType);
+            return util->SetKeyword<<%= kw[1] %>>(kws.str_, kws.token_type_);
         }
 %   end
 % end
diff --git a/lexer/token/sourceLocation.cpp b/lexer/token/sourceLocation.cpp
index 9d1e4ea60474c0cdcdee2a703c35ae8e5bab8698..b37e7dcbbd8c9b183720f3254997c11352ec9a42 100644
--- a/lexer/token/sourceLocation.cpp
+++ b/lexer/token/sourceLocation.cpp
@@ -26,17 +26,17 @@ void OffsetEntry::AddCol(size_t offset)
     size_t diff = offset - offset_;
     offset_ = offset;
 
-    if (ranges.empty()) {
-        ranges.emplace_back(Range {diff});
+    if (ranges_.empty()) {
+        ranges_.emplace_back(Range {diff});
         return;
     }
 
-    auto &range = ranges.back();
+    auto &range = ranges_.back();
 
-    if (diff == range.byteSize) {
-        range.cnt++;
+    if (diff == range.byte_size_) {
+        range.cnt_++;
     } else {
-        ranges.emplace_back(Range {diff});
+        ranges_.emplace_back(Range {diff});
     }
 }
 
@@ -72,20 +72,20 @@ LineIndex::LineIndex(const util::StringView &source) noexcept
 
 SourceLocation LineIndex::GetLocation(SourcePosition pos) noexcept
 {
-    size_t line = pos.line;
+    size_t line = pos.line_;
 
     size_t col = 0;
-    const auto &entry = entrys_[pos.line];
-    size_t diff = pos.index - entry.lineStart;
+    const auto &entry = entrys_[pos.line_];
+    size_t diff = pos.index_ - entry.line_start_;
 
-    for (const auto &range : entry.ranges) {
-        if (diff < range.cnt) {
+    for (const auto &range : entry.ranges_) {
+        if (diff < range.cnt_) {
             col += diff;
             break;
         }
 
-        diff -= range.cnt * range.byteSize;
-        col += range.cnt;
+        diff -= range.cnt_ * range.byte_size_;
+        col += range.cnt_;
     }
 
     return SourceLocation(line + 1, col + 1);
diff --git a/lexer/token/sourceLocation.h b/lexer/token/sourceLocation.h
index 7f0fa27a2c521d90aa35eac03f8d8f505804a2c4..5c99f5bd56cc3a94e0cfc5cf229e2d0ed560f473 100644
--- a/lexer/token/sourceLocation.h
+++ b/lexer/token/sourceLocation.h
@@ -28,54 +28,54 @@ namespace panda::es2panda::lexer {
 class SourcePosition {
 public:
     explicit SourcePosition() noexcept = default;
-    explicit SourcePosition(size_t i, size_t l) noexcept : index(i), line(l) {}
+    explicit SourcePosition(size_t i, size_t l) noexcept : index_(i), line_(l) {}
     DEFAULT_COPY_SEMANTIC(SourcePosition);
     DEFAULT_MOVE_SEMANTIC(SourcePosition);
     ~SourcePosition() = default;
 
-    size_t index {};
-    size_t line {};
+    size_t index_ {};
+    size_t line_ {};
 };
 
 class SourceRange {
 public:
     explicit SourceRange() noexcept = default;
-    SourceRange(SourcePosition s, SourcePosition e) noexcept : start(s), end(e) {}
+    SourceRange(SourcePosition s, SourcePosition e) noexcept : start_(s), end_(e) {}
     DEFAULT_COPY_SEMANTIC(SourceRange);
     DEFAULT_MOVE_SEMANTIC(SourceRange);
     ~SourceRange() = default;
 
-    SourcePosition start {};
-    SourcePosition end {};
+    SourcePosition start_ {};
+    SourcePosition end_ {};
 };
 
 class SourceLocation {
 public:
     explicit SourceLocation() noexcept = default;
-    explicit SourceLocation(size_t l, size_t c) noexcept : line(l), col(c) {}
+    explicit SourceLocation(size_t l, size_t c) noexcept : line_(l), col_(c) {}
     DEFAULT_COPY_SEMANTIC(SourceLocation);
     DEFAULT_MOVE_SEMANTIC(SourceLocation);
     ~SourceLocation() = default;
 
-    size_t line {};
-    size_t col {};
+    size_t line_ {};
+    size_t col_ {};
 };
 
 class Range {
 public:
-    explicit Range(size_t bS) noexcept : byteSize(bS) {}
+    explicit Range(size_t bS) noexcept : byte_size_(bS) {}
 
     DEFAULT_COPY_SEMANTIC(Range);
     DEFAULT_MOVE_SEMANTIC(Range);
     ~Range() = default;
 
-    size_t byteSize {};
-    size_t cnt {1};
+    size_t byte_size_ {};
+    size_t cnt_ {1};
 };
 
 class OffsetEntry {
 public:
-    explicit OffsetEntry(size_t l) : lineStart(l), offset_(l) {};
+    explicit OffsetEntry(size_t l) : line_start_(l), offset_(l) {};
 
     DEFAULT_COPY_SEMANTIC(OffsetEntry);
     DEFAULT_MOVE_SEMANTIC(OffsetEntry);
@@ -83,8 +83,8 @@ public:
 
     void AddCol(size_t offset);
 
-    std::vector<Range> ranges {};
-    size_t lineStart {};
+    std::vector<Range> ranges_ {};
+    size_t line_start_ {};
 
 private:
     size_t offset_ {};
diff --git a/lexer/token/token.cpp b/lexer/token/token.cpp
index 12521b9dada193b33275e445a53d6700fe3a9e84..b848b1aa7e7eb38f17d8146b59a3c202e55978e4 100644
--- a/lexer/token/token.cpp
+++ b/lexer/token/token.cpp
@@ -20,32 +20,32 @@ namespace panda::es2panda::lexer {
 bool Token::IsAccessability() const
 {
     return (type_ == TokenType::LITERAL_IDENT &&
-            (keywordType_ == TokenType::KEYW_PUBLIC || keywordType_ == TokenType::KEYW_PROTECTED ||
-             keywordType_ == TokenType::KEYW_PRIVATE) &&
+            (keyword_type_ == TokenType::KEYW_PUBLIC || keyword_type_ == TokenType::KEYW_PROTECTED ||
+             keyword_type_ == TokenType::KEYW_PRIVATE) &&
             !(flags_ & TokenFlags::HAS_ESCAPE));
 }
 
 bool Token::IsAsyncModifier() const
 {
-    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_ASYNC &&
+    return (type_ == TokenType::LITERAL_IDENT && keyword_type_ == TokenType::KEYW_ASYNC &&
             !(flags_ & TokenFlags::HAS_ESCAPE));
 }
 
 bool Token::IsStaticModifier() const
 {
-    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_STATIC &&
+    return (type_ == TokenType::LITERAL_IDENT && keyword_type_ == TokenType::KEYW_STATIC &&
             !(flags_ & TokenFlags::HAS_ESCAPE));
 }
 
 bool Token::IsDeclareModifier() const
 {
-    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_DECLARE &&
+    return (type_ == TokenType::LITERAL_IDENT && keyword_type_ == TokenType::KEYW_DECLARE &&
             !(flags_ & TokenFlags::HAS_ESCAPE));
 }
 
 bool Token::IsReadonlyModifier() const
 {
-    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_READONLY &&
+    return (type_ == TokenType::LITERAL_IDENT && keyword_type_ == TokenType::KEYW_READONLY &&
             !(flags_ & TokenFlags::HAS_ESCAPE));
 }
 
@@ -76,7 +76,7 @@ bool Token::IsKeyword() const
 
 bool Token::IsReservedTypeName() const
 {
-    switch (keywordType_) {
+    switch (keyword_type_) {
         case TokenType::KEYW_ANY:
         case TokenType::KEYW_UNKNOWN:
         case TokenType::KEYW_NEVER:
diff --git a/lexer/token/token.h b/lexer/token/token.h
index 46a87d432cc1ff7cf96671e75e9391c196b298ae..f23521afdd45b9675f869e2abef84a95f3df526d 100644
--- a/lexer/token/token.h
+++ b/lexer/token/token.h
@@ -60,17 +60,17 @@ public:
 
     TokenType KeywordType() const
     {
-        return keywordType_;
+        return keyword_type_;
     }
 
     const SourcePosition &Start() const
     {
-        return loc_.start;
+        return loc_.start_;
     }
 
     const SourcePosition &End() const
     {
-        return loc_.end;
+        return loc_.end_;
     }
 
     const SourceRange &Loc() const
@@ -126,7 +126,7 @@ public:
 private:
     friend class KeywordsUtil;
     TokenType type_ {TokenType::EOS};
-    TokenType keywordType_ {TokenType::EOS};
+    TokenType keyword_type_ {TokenType::EOS};
     TokenFlags flags_ {TokenFlags::NONE};
     SourceRange loc_ {};
     double number_ {};
diff --git a/parser/expressionParser.cpp b/parser/expressionParser.cpp
index f3db9c0354ad0562dc84c431b5bba5d8c34c655e..f4f4fac490e398f7942116284a64a43a85a8c9fd 100644
--- a/parser/expressionParser.cpp
+++ b/parser/expressionParser.cpp
@@ -280,7 +280,7 @@ ir::Expression *ParserImpl::ParseArrayExpression(ExpressionParseFlags flags)
         } else if (!inPattern && lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
             ir::ValidationInfo info = arrayExpressionNode->ValidateExpression();
             if (info.Fail()) {
-                ThrowSyntaxError(info.msg.Utf8(), info.pos);
+                ThrowSyntaxError(info.msg_.Utf8(), info.pos_);
             }
         }
     }
@@ -365,10 +365,10 @@ ir::ArrowFunctionExpression *ParserImpl::ParseArrowFunctionExpressionBody(ArrowF
                                                                           ir::TSTypeParameterDeclaration *typeParamDecl,
                                                                           ir::Expression *returnTypeAnnotation)
 {
-    context_.Status() |= desc->newStatus;
+    context_.Status() |= desc->new_status_;
 
-    functionScope->BindParamScope(desc->paramScope);
-    desc->paramScope->BindFunctionScope(functionScope);
+    functionScope->BindParamScope(desc->param_scope_);
+    desc->param_scope_->BindFunctionScope(functionScope);
 
     lexer_->NextToken();  // eat '=>'
     ir::ScriptFunction *funcNode {};
@@ -395,11 +395,11 @@ ir::ArrowFunctionExpression *ParserImpl::ParseArrowFunctionExpressionBody(ArrowF
         endLoc = body->End();
     }
 
-    funcNode = AllocNode<ir::ScriptFunction>(functionScope, std::move(desc->params), typeParamDecl, body,
+    funcNode = AllocNode<ir::ScriptFunction>(functionScope, std::move(desc->params_), typeParamDecl, body,
                                              returnTypeAnnotation, arrowFunctionContext->Flags(), false);
-    funcNode->SetRange({desc->startLoc, endLoc});
+    funcNode->SetRange({desc->start_loc_, endLoc});
     functionScope->BindNode(funcNode);
-    desc->paramScope->BindNode(funcNode);
+    desc->param_scope_->BindNode(funcNode);
 
     auto *arrowFuncNode = AllocNode<ir::ArrowFunctionExpression>(funcNode);
     arrowFuncNode->SetRange(funcNode->Range());
@@ -672,14 +672,14 @@ void ParserImpl::ValidateParenthesizedExpression(ir::Expression *lhsExpression)
         case ir::AstNodeType::ARRAY_EXPRESSION: {
             auto info = lhsExpression->AsArrayExpression()->ValidateExpression();
             if (info.Fail()) {
-                ThrowSyntaxError(info.msg.Utf8(), info.pos);
+                ThrowSyntaxError(info.msg_.Utf8(), info.pos_);
             }
             break;
         }
         case ir::AstNodeType::OBJECT_EXPRESSION: {
             auto info = lhsExpression->AsObjectExpression()->ValidateExpression();
             if (info.Fail()) {
-                ThrowSyntaxError(info.msg.Utf8(), info.pos);
+                ThrowSyntaxError(info.msg_.Utf8(), info.pos_);
             }
             break;
         }
@@ -829,14 +829,14 @@ ir::TemplateLiteral *ParserImpl::ParseTemplateLiteral()
         util::StringView cooked = lexer_->GetToken().String();
 
         lexer_->Rewind(startPos);
-        auto [raw, end, scanExpression] = lexer_->ScanTemplateString();
+        auto [raw, end_, scan_expression_] = lexer_->ScanTemplateString();
 
         auto *element = AllocNode<ir::TemplateElement>(raw.View(), cooked);
-        element->SetRange({lexer::SourcePosition {startPos.iterator.Index(), startPos.line},
-                           lexer::SourcePosition {end, lexer_->Line()}});
+        element->SetRange({lexer::SourcePosition {startPos.iterator_.Index(), startPos.line_},
+                           lexer::SourcePosition {end_, lexer_->Line()}});
         quasis.push_back(element);
 
-        if (!scanExpression) {
+        if (!scan_expression_) {
             lexer_->ScanTemplateStringEnd();
             break;
         }
@@ -1023,10 +1023,10 @@ ir::Expression *ParserImpl::ParsePrimaryExpression(ExpressionParseFlags flags)
             try {
                 reParser.ParsePattern();
             } catch (lexer::RegExpError &e) {
-                ThrowSyntaxError(e.message.c_str());
+                ThrowSyntaxError(e.message_.c_str());
             }
 
-            auto *regexpNode = AllocNode<ir::RegExpLiteral>(regexp.patternStr, regexp.flagsStr);
+            auto *regexpNode = AllocNode<ir::RegExpLiteral>(regexp.pattern_str_, regexp.flags_str_);
             regexpNode->SetRange(lexer_->GetToken().Loc());
 
             lexer_->NextToken();
@@ -2151,7 +2151,7 @@ ir::ObjectExpression *ParserImpl::ParseObjectExpression(ExpressionParseFlags fla
         } else if (!inPattern && lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
             ir::ValidationInfo info = objectExpression->ValidateExpression();
             if (info.Fail()) {
-                ThrowSyntaxError(info.msg.Utf8(), info.pos);
+                ThrowSyntaxError(info.msg_.Utf8(), info.pos_);
             }
         }
     }
diff --git a/parser/parserImpl.cpp b/parser/parserImpl.cpp
index 87204a430fb3992a882b68eb80f0ec50d7c4f0cb..804824516c7924bbf99704d85616f0b09fc4751d 100644
--- a/parser/parserImpl.cpp
+++ b/parser/parserImpl.cpp
@@ -1747,7 +1747,7 @@ void ParserImpl::ParseClassKeyModifiers(ClassElmentDescriptor *desc)
         (Extension() == ScriptExtension::TS && nextCp != LEX_CHAR_EQUALS && nextCp != LEX_CHAR_SEMICOLON &&
          nextCp != LEX_CHAR_LEFT_PAREN)) {
         if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_GET) {
-            if (desc->isPrivateIdent) {
+            if (desc->is_private_ident_) {
                 ThrowSyntaxError("Private identifier can not be getter");
             }
 
@@ -1755,12 +1755,12 @@ void ParserImpl::ParseClassKeyModifiers(ClassElmentDescriptor *desc)
                 ThrowSyntaxError("Keyword must not contain escaped characters");
             }
 
-            desc->methodKind = ir::MethodDefinitionKind::GET;
-            desc->methodStart = lexer_->GetToken().Start();
+            desc->method_kind_ = ir::MethodDefinitionKind::GET;
+            desc->method_start_ = lexer_->GetToken().Start();
 
             lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
         } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_SET) {
-            if (desc->isPrivateIdent) {
+            if (desc->is_private_ident_) {
                 ThrowSyntaxError("Private identifier can not be setter");
             }
 
@@ -1768,8 +1768,8 @@ void ParserImpl::ParseClassKeyModifiers(ClassElmentDescriptor *desc)
                 ThrowSyntaxError("Keyword must not contain escaped characters");
             }
 
-            desc->methodKind = ir::MethodDefinitionKind::SET;
-            desc->methodStart = lexer_->GetToken().Start();
+            desc->method_kind_ = ir::MethodDefinitionKind::SET;
+            desc->method_start_ = lexer_->GetToken().Start();
 
             lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
         }
@@ -1778,15 +1778,15 @@ void ParserImpl::ParseClassKeyModifiers(ClassElmentDescriptor *desc)
 
 void ParserImpl::ThrowIfPrivateIdent(ClassElmentDescriptor *desc, const char *msg)
 {
-    if (desc->isPrivateIdent) {
+    if (desc->is_private_ident_) {
         ThrowSyntaxError(msg);
     }
 }
 
 void ParserImpl::ValidateClassKey(ClassElmentDescriptor *desc)
 {
-    if ((desc->modifiers & ir::ModifierFlags::ASYNC) &&
-        (desc->methodKind == ir::MethodDefinitionKind::GET || desc->methodKind == ir::MethodDefinitionKind::SET)) {
+    if ((desc->modifiers_ & ir::ModifierFlags::ASYNC) &&
+        (desc->method_kind_ == ir::MethodDefinitionKind::GET || desc->method_kind_ == ir::MethodDefinitionKind::SET)) {
         ThrowSyntaxError("Async method can not be getter nor setter");
     }
 
@@ -1795,23 +1795,23 @@ void ParserImpl::ValidateClassKey(ClassElmentDescriptor *desc)
     if (propNameStr.Is("constructor")) {
         ThrowIfPrivateIdent(desc, "Private identifier can not be constructor");
 
-        if (!(desc->modifiers & ir::ModifierFlags::STATIC)) {
-            if ((desc->modifiers & ir::ModifierFlags::ASYNC) || desc->methodKind == ir::MethodDefinitionKind::GET ||
-                desc->methodKind == ir::MethodDefinitionKind::SET || desc->isGenerator) {
+        if (!(desc->modifiers_ & ir::ModifierFlags::STATIC)) {
+            if ((desc->modifiers_ & ir::ModifierFlags::ASYNC) || desc->method_kind_ == ir::MethodDefinitionKind::GET ||
+                desc->method_kind_ == ir::MethodDefinitionKind::SET || desc->is_generator_) {
                 ThrowSyntaxError("Constructor can not be special method");
             }
 
-            desc->methodKind = ir::MethodDefinitionKind::CONSTRUCTOR;
-            desc->methodStart = lexer_->GetToken().Start();
-            desc->newStatus |= ParserStatus::CONSTRUCTOR_FUNCTION;
+            desc->method_kind_ = ir::MethodDefinitionKind::CONSTRUCTOR;
+            desc->method_start_ = lexer_->GetToken().Start();
+            desc->new_status_ |= ParserStatus::CONSTRUCTOR_FUNCTION;
 
-            if (desc->hasSuperClass) {
-                desc->newStatus |= ParserStatus::ALLOW_SUPER_CALL;
+            if (desc->has_super_class_) {
+                desc->new_status_ |= ParserStatus::ALLOW_SUPER_CALL;
             }
         } else if (Extension() == ScriptExtension::TS) {
             ThrowSyntaxError("Static modifier can not appear on a constructor");
         }
-    } else if (propNameStr.Is("prototype") && (desc->modifiers & ir::ModifierFlags::STATIC)) {
+    } else if (propNameStr.Is("prototype") && (desc->modifiers_ & ir::ModifierFlags::STATIC)) {
         ThrowSyntaxError("Classes may not have static property named prototype");
     }
 }
@@ -1857,7 +1857,7 @@ ir::Expression *ParserImpl::ParseClassKey(ClassElmentDescriptor *desc)
 
             if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT &&
                 lexer_->Lookahead() == LEX_CHAR_COLON) {
-                desc->isIndexSignature = true;
+                desc->is_index_signature_ = true;
 
                 propName = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
                 propName->SetRange(lexer_->GetToken().Loc());
@@ -1889,12 +1889,12 @@ ir::Expression *ParserImpl::ParseClassKey(ClassElmentDescriptor *desc)
                 return propName;
             }
 
-            desc->isComputed = true;
+            desc->is_computed_ = true;
 
             propName = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
 
             if (Extension() == ScriptExtension::TS) {
-                desc->invalidComputedProperty =
+                desc->invalid_computed_property_ =
                     !propName->IsNumberLiteral() && !propName->IsStringLiteral() &&
                     !(propName->IsMemberExpression() && propName->AsMemberExpression()->Object()->IsIdentifier() &&
                       propName->AsMemberExpression()->Object()->AsIdentifier()->Name().Is("Symbol"));
@@ -1921,28 +1921,28 @@ void ParserImpl::ValidateClassMethodStart(ClassElmentDescriptor *desc, ir::Expre
         if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
             return;
         }
-        desc->classMethod = true;
+        desc->class_method_ = true;
     }
 
     if (Extension() == ScriptExtension::TS &&
-        lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS && desc->isPrivateIdent) {
+        lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS && desc->is_private_ident_) {
         ThrowSyntaxError("A method cannot be named with a private identifier");
     }
 
     if (Extension() == ScriptExtension::TS) {
         if (!typeAnnotation && (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS ||
                                 lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN)) {
-            if ((desc->modifiers & (ir::ModifierFlags::DECLARE | ir::ModifierFlags::READONLY))) {
+            if ((desc->modifiers_ & (ir::ModifierFlags::DECLARE | ir::ModifierFlags::READONLY))) {
                 ThrowSyntaxError("Class method can not be declare nor readonly");
             }
-            desc->classMethod = true;
+            desc->class_method_ = true;
         } else {
-            if ((desc->modifiers & ir::ModifierFlags::ASYNC) || desc->isGenerator) {
+            if ((desc->modifiers_ & ir::ModifierFlags::ASYNC) || desc->is_generator_) {
                 ThrowSyntaxError("Expected '('");
             }
-            desc->classField = true;
+            desc->class_field_ = true;
 
-            if (desc->invalidComputedProperty) {
+            if (desc->invalid_computed_property_) {
                 ThrowSyntaxError(
                     "Computed property name must refer to a symbol or "
                     "literal expression whos value is "
@@ -1951,12 +1951,12 @@ void ParserImpl::ValidateClassMethodStart(ClassElmentDescriptor *desc, ir::Expre
         }
     }
 
-    if (desc->modifiers & ir::ModifierFlags::ASYNC) {
-        desc->newStatus |= ParserStatus::ASYNC_FUNCTION;
+    if (desc->modifiers_ & ir::ModifierFlags::ASYNC) {
+        desc->new_status_ |= ParserStatus::ASYNC_FUNCTION;
     }
 
-    if (desc->isGenerator) {
-        desc->newStatus |= ParserStatus::GENERATOR_FUNCTION;
+    if (desc->is_generator_) {
+        desc->new_status_ |= ParserStatus::GENERATOR_FUNCTION;
     }
 }
 
@@ -1968,8 +1968,8 @@ void ParserImpl::ValidateClassSetter(ClassElmentDescriptor *desc, const ArenaVec
         ThrowSyntaxError("Setter must have exactly one formal parameter");
     }
 
-    if (Extension() == ScriptExtension::TS && !(desc->modifiers & ir::ModifierFlags::STATIC)) {
-        ir::ModifierFlags access = GetAccessability(desc->modifiers);
+    if (Extension() == ScriptExtension::TS && !(desc->modifiers_ & ir::ModifierFlags::STATIC)) {
+        ir::ModifierFlags access = GetAccessability(desc->modifiers_);
         CheckAccessorPair(properties, propName, ir::MethodDefinitionKind::GET, access, hasDecorator, errorInfo);
     }
 }
@@ -1982,8 +1982,8 @@ void ParserImpl::ValidateClassGetter(ClassElmentDescriptor *desc, const ArenaVec
         ThrowSyntaxError("Getter must not have formal parameters");
     }
 
-    if (Extension() == ScriptExtension::TS && !(desc->modifiers & ir::ModifierFlags::STATIC)) {
-        ir::ModifierFlags access = GetAccessability(desc->modifiers);
+    if (Extension() == ScriptExtension::TS && !(desc->modifiers_ & ir::ModifierFlags::STATIC)) {
+        ir::ModifierFlags access = GetAccessability(desc->modifiers_);
 
         CheckAccessorPair(properties, propName, ir::MethodDefinitionKind::SET, access, hasDecorator, errorInfo);
     }
@@ -1995,22 +1995,23 @@ ir::MethodDefinition *ParserImpl::ParseClassMethod(ClassElmentDescriptor *desc,
                                                    ArenaVector<ir::Decorator *> &&decorators, bool isDeclare)
 {
     if (Extension() == ScriptExtension::TS) {
-        if (desc->methodKind == ir::MethodDefinitionKind::SET || desc->methodKind == ir::MethodDefinitionKind::GET) {
-            desc->newStatus |= ParserStatus::ACCESSOR_FUNCTION;
+        if (desc->method_kind_ == ir::MethodDefinitionKind::SET ||
+            desc->method_kind_ == ir::MethodDefinitionKind::GET) {
+            desc->new_status_ |= ParserStatus::ACCESSOR_FUNCTION;
         }
 
-        desc->newStatus |= ParserStatus::IN_METHOD_DEFINITION;
+        desc->new_status_ |= ParserStatus::IN_METHOD_DEFINITION;
     }
 
-    if (isDeclare && (desc->newStatus & ParserStatus::ASYNC_FUNCTION)) {
+    if (isDeclare && (desc->new_status_ & ParserStatus::ASYNC_FUNCTION)) {
         ThrowSyntaxError("'async' modifier cannot be used in an ambient context.");
     }
 
-    if (isDeclare && desc->isGenerator) {
+    if (isDeclare && desc->is_generator_) {
         ThrowSyntaxError("Generators are not allowed in an ambient context.");
     }
 
-    ir::ScriptFunction *func = ParseFunction(desc->newStatus, isDeclare);
+    ir::ScriptFunction *func = ParseFunction(desc->new_status_, isDeclare);
 
     if (func->IsOverload() && !decorators.empty()) {
         ThrowSyntaxError("A decorator can only decorate a method implementation, not an overload.",
@@ -2022,16 +2023,16 @@ ir::MethodDefinition *ParserImpl::ParseClassMethod(ClassElmentDescriptor *desc,
 
     lexer::SourcePosition errorInfo = decorators.empty() ? func->Start() : decorators[0]->Start();
 
-    if (desc->methodKind == ir::MethodDefinitionKind::SET) {
+    if (desc->method_kind_ == ir::MethodDefinitionKind::SET) {
         ValidateClassSetter(desc, properties, propName, func, !decorators.empty(), errorInfo);
-    } else if (desc->methodKind == ir::MethodDefinitionKind::GET) {
+    } else if (desc->method_kind_ == ir::MethodDefinitionKind::GET) {
         ValidateClassGetter(desc, properties, propName, func, !decorators.empty(), errorInfo);
     }
 
     *propEnd = func->End();
     func->AddFlag(ir::ScriptFunctionFlags::METHOD);
-    auto *method = AllocNode<ir::MethodDefinition>(desc->methodKind, propName, funcExpr, desc->modifiers, Allocator(),
-                                                   std::move(decorators), desc->isComputed);
+    auto *method = AllocNode<ir::MethodDefinition>(desc->method_kind_, propName, funcExpr, desc->modifiers_,
+                                                   Allocator(), std::move(decorators), desc->is_computed_);
     method->SetRange(funcExpr->Range());
     return method;
 }
@@ -2044,9 +2045,9 @@ ir::Statement *ParserImpl::ParseClassProperty(ClassElmentDescriptor *desc,
     lexer::SourcePosition propEnd = propName->End();
     ir::Statement *property = nullptr;
 
-    if (desc->classMethod) {
+    if (desc->class_method_) {
         property = ParseClassMethod(desc, properties, propName, &propEnd, std::move(decorators), isDeclare);
-        property->SetRange({desc->propStart, propEnd});
+        property->SetRange({desc->prop_start_, propEnd});
         return property;
     }
 
@@ -2065,21 +2066,21 @@ ir::Statement *ParserImpl::ParseClassProperty(ClassElmentDescriptor *desc,
     ir::Expression *privateId = nullptr;
 
     if (Extension() == ScriptExtension::JS) {
-        if (desc->isPrivateIdent) {
+        if (desc->is_private_ident_) {
             ThrowSyntaxError("Private js fields are not supported");
         }
     } else {
-        if (desc->isPrivateIdent) {
+        if (desc->is_private_ident_) {
             privateId = AllocNode<ir::TSPrivateIdentifier>(propName, value, typeAnnotation);
-            privateId->SetRange({desc->propStart, propName->End()});
+            privateId->SetRange({desc->prop_start_, propName->End()});
         }
     }
 
-    property = AllocNode<ir::ClassProperty>(desc->isPrivateIdent ? privateId : propName, value, typeAnnotation,
-                                            desc->modifiers, std::move(decorators), desc->isComputed,
-                                            desc->modifiers & ir::ModifierFlags::DEFINITE);
+    property = AllocNode<ir::ClassProperty>(desc->is_private_ident_ ? privateId : propName, value, typeAnnotation,
+                                            desc->modifiers_, std::move(decorators), desc->is_computed_,
+                                            desc->modifiers_ & ir::ModifierFlags::DEFINITE);
 
-    property->SetRange({desc->propStart, propEnd});
+    property->SetRange({desc->prop_start_, propEnd});
     return property;
 }
 
@@ -2091,7 +2092,7 @@ void ParserImpl::CheckClassGeneratorMethod(ClassElmentDescriptor *desc)
 
     ThrowIfPrivateIdent(desc, "Unexpected character in private identifier");
 
-    desc->isGenerator = true;
+    desc->is_generator_ = true;
     lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
 }
 
@@ -2109,11 +2110,11 @@ void ParserImpl::CheckClassPrivateIdentifier(ClassElmentDescriptor *desc)
         return;
     }
 
-    if (desc->modifiers != ir::ModifierFlags::NONE) {
+    if (desc->modifiers_ != ir::ModifierFlags::NONE) {
         ThrowSyntaxError("Unexpected modifier on private identifier");
     }
 
-    desc->isPrivateIdent = true;
+    desc->is_private_ident_ = true;
     lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
 }
 
@@ -2171,16 +2172,16 @@ ir::Statement *ParserImpl::ParseClassElement(const ArenaVector<ir::Statement *>
 {
     ClassElmentDescriptor desc;
 
-    desc.methodKind = ir::MethodDefinitionKind::METHOD;
-    desc.newStatus = ParserStatus::ALLOW_SUPER;
-    desc.hasSuperClass = hasSuperClass;
-    desc.propStart = lexer_->GetToken().Start();
+    desc.method_kind_ = ir::MethodDefinitionKind::METHOD;
+    desc.new_status_ = ParserStatus::ALLOW_SUPER;
+    desc.has_super_class_ = hasSuperClass;
+    desc.prop_start_ = lexer_->GetToken().Start();
 
     auto decorators = ParseDecorators();
 
-    desc.modifiers = ParseModifiers();
+    desc.modifiers_ = ParseModifiers();
 
-    if ((desc.modifiers & ir::ModifierFlags::ABSTRACT) && !isAbstractClass) {
+    if ((desc.modifiers_ & ir::ModifierFlags::ABSTRACT) && !isAbstractClass) {
         ThrowSyntaxError("Abstract methods can only appear within an abstract class.");
     }
 
@@ -2188,41 +2189,41 @@ ir::Statement *ParserImpl::ParseClassElement(const ArenaVector<ir::Statement *>
     CheckClassGeneratorMethod(&desc);
     ParseClassKeyModifiers(&desc);
 
-    if (!(desc.modifiers & ir::ModifierFlags::STATIC)) {
+    if (!(desc.modifiers_ & ir::ModifierFlags::STATIC)) {
         context_.Status() |= ParserStatus::ALLOW_THIS_TYPE;
     }
 
     ir::Expression *propName = ParseClassKey(&desc);
 
-    if (desc.methodKind == ir::MethodDefinitionKind::CONSTRUCTOR && !decorators.empty()) {
+    if (desc.method_kind_ == ir::MethodDefinitionKind::CONSTRUCTOR && !decorators.empty()) {
         ThrowSyntaxError("Decorators are not valid here.", decorators.front()->Start());
     }
 
     if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_QUESTION_MARK) {
-        if (desc.isIndexSignature) {
+        if (desc.is_index_signature_) {
             ThrowSyntaxError("';' expected");
         }
 
-        if (desc.methodKind == ir::MethodDefinitionKind::CONSTRUCTOR) {
+        if (desc.method_kind_ == ir::MethodDefinitionKind::CONSTRUCTOR) {
             ThrowSyntaxError("'(' expected");
         }
 
-        desc.modifiers |= ir::ModifierFlags::OPTIONAL;
+        desc.modifiers_ |= ir::ModifierFlags::OPTIONAL;
         lexer_->NextToken();
     } else if (Extension() == ScriptExtension::TS &&
                lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_EXCLAMATION_MARK) {
-        if (desc.isIndexSignature || lexer_->Lookahead() != LEX_CHAR_COLON) {
+        if (desc.is_index_signature_ || lexer_->Lookahead() != LEX_CHAR_COLON) {
             ThrowSyntaxError("';' expected");
         }
 
-        desc.modifiers |= ir::ModifierFlags::DEFINITE;
+        desc.modifiers_ |= ir::ModifierFlags::DEFINITE;
         lexer_->NextToken();
     }
 
     ir::Expression *typeAnnotation = ParseClassKeyAnnotation();
 
     ir::Statement *property = nullptr;
-    if (desc.isIndexSignature) {
+    if (desc.is_index_signature_) {
         if (!decorators.empty()) {
             ThrowSyntaxError("Decorators are not valid here.", decorators.front()->Start());
         }
@@ -2232,7 +2233,7 @@ ir::Statement *ParserImpl::ParseClassElement(const ArenaVector<ir::Statement *>
         }
 
         auto *indexSignature =
-            AllocNode<ir::TSIndexSignature>(propName, typeAnnotation, desc.modifiers & ir::ModifierFlags::READONLY);
+            AllocNode<ir::TSIndexSignature>(propName, typeAnnotation, desc.modifiers_ & ir::ModifierFlags::READONLY);
 
         indexSignature->SetRange({indexSignature->Param()->Start(), indexSignature->TypeAnnotation()->End()});
 
@@ -2242,7 +2243,7 @@ ir::Statement *ParserImpl::ParseClassElement(const ArenaVector<ir::Statement *>
     } else {
         ValidateClassMethodStart(&desc, typeAnnotation);
         property = ParseClassProperty(&desc, properties, propName, typeAnnotation, std::move(decorators),
-                                      isDeclare || (desc.modifiers & ir::ModifierFlags::DECLARE));
+                                      isDeclare || (desc.modifiers_ & ir::ModifierFlags::DECLARE));
     }
 
     if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON &&
@@ -3244,7 +3245,7 @@ void ParserImpl::ThrowSyntaxError(std::string_view errorMessage, const lexer::So
     lexer::LineIndex index(program_.SourceCode());
     lexer::SourceLocation loc = index.GetLocation(pos);
 
-    throw Error {ErrorType::SYNTAX, errorMessage, loc.line, loc.col};
+    throw Error {ErrorType::SYNTAX, errorMessage, loc.line_, loc.col_};
 }
 
 ScriptExtension ParserImpl::Extension() const
@@ -3264,7 +3265,7 @@ void ExportDeclarationContext::BindExportDecl(const ir::AstNode *exportDecl)
         const auto *decl = exportDecl->AsExportDefaultDeclaration();
         const auto *rhs = decl->Decl();
 
-        if (binder_->GetScope()->Bindings().size() == savedBindings_.size()) {
+        if (binder_->GetScope()->Bindings().size() == saved_bindings_.size()) {
             if (rhs->IsFunctionDeclaration()) {
                 binder_->AddDecl<binder::FunctionDecl>(rhs->Start(), binder_->Allocator(),
                                                        util::StringView(DEFAULT_EXPORT),
@@ -3276,7 +3277,7 @@ void ExportDeclarationContext::BindExportDecl(const ir::AstNode *exportDecl)
     }
 
     for (const auto &[name, variable] : binder_->GetScope()->Bindings()) {
-        if (savedBindings_.find(name) != savedBindings_.end()) {
+        if (saved_bindings_.find(name) != saved_bindings_.end()) {
             continue;
         }
 
@@ -3296,7 +3297,7 @@ void ImportDeclarationContext::BindImportDecl(const ir::ImportDeclaration *impor
     binder::ModuleScope::ImportDeclList declList(Allocator()->Adapter());
 
     for (const auto &[name, variable] : binder_->GetScope()->Bindings()) {
-        if (savedBindings_.find(name) != savedBindings_.end()) {
+        if (saved_bindings_.find(name) != saved_bindings_.end()) {
             continue;
         }
 
diff --git a/parser/parserImpl.h b/parser/parserImpl.h
index 2d8f1fa250875db003f5aaacde389495e0fabe2d..14928f5e1329b4655943a0bfc949f11ecd4490f0 100644
--- a/parser/parserImpl.h
+++ b/parser/parserImpl.h
@@ -124,33 +124,33 @@ class ParserContext;
 
 class ClassElmentDescriptor {
 public:
-    ir::MethodDefinitionKind methodKind {};
-    ParserStatus newStatus {};
-    ir::ModifierFlags modifiers {};
-    lexer::SourcePosition methodStart {};
-    lexer::SourcePosition propStart {};
-    bool isPrivateIdent {};
-    bool hasSuperClass {};
-    bool isGenerator {};
-    bool invalidComputedProperty {};
-    bool isComputed {};
-    bool isIndexSignature {};
-    bool classMethod {};
-    bool classField {};
+    ir::MethodDefinitionKind method_kind_ {};
+    ParserStatus new_status_ {};
+    ir::ModifierFlags modifiers_ {};
+    lexer::SourcePosition method_start_ {};
+    lexer::SourcePosition prop_start_ {};
+    bool is_private_ident_ {};
+    bool has_super_class_ {};
+    bool is_generator_ {};
+    bool invalid_computed_property_ {};
+    bool is_computed_ {};
+    bool is_index_signature_ {};
+    bool class_method_ {};
+    bool class_field_ {};
 };
 
 class ArrowFunctionDescriptor {
 public:
     explicit ArrowFunctionDescriptor(ArenaVector<ir::Expression *> &&p, binder::FunctionParamScope *ps,
                                      lexer::SourcePosition sl, ParserStatus ns)
-        : params(p), paramScope(ps), startLoc(sl), newStatus(ns)
+        : params_(p), param_scope_(ps), start_loc_(sl), new_status_(ns)
     {
     }
 
-    ArenaVector<ir::Expression *> params;
-    binder::FunctionParamScope *paramScope;
-    lexer::SourcePosition startLoc;
-    ParserStatus newStatus;
+    ArenaVector<ir::Expression *> params_;
+    binder::FunctionParamScope *param_scope_;
+    lexer::SourcePosition start_loc_;
+    ParserStatus new_status_;
 };
 
 enum class TypeAnnotationParsingOptions {
@@ -482,7 +482,7 @@ class SavedStatusContext {
 public:
     explicit SavedStatusContext(ParserContext *ctx)
         // NOLINTNEXTLINE(readability-magic-numbers)
-        : ctx_(ctx), savedStatus_(static_cast<ParserStatus>(ctx->Status() & status))
+        : ctx_(ctx), saved_status_(static_cast<ParserStatus>(ctx->Status() & status))
     {
         // NOLINTNEXTLINE(readability-magic-numbers)
         ctx->Status() |= status;
@@ -493,14 +493,14 @@ public:
 
     ~SavedStatusContext()
     {
-        if (savedStatus_ == ParserStatus::NO_OPTS) {
-            ctx_->Status() &= ~savedStatus_;
+        if (saved_status_ == ParserStatus::NO_OPTS) {
+            ctx_->Status() &= ~saved_status_;
         }
     }
 
 private:
     ParserContext *ctx_;
-    ParserStatus savedStatus_;
+    ParserStatus saved_status_;
 };
 
 class SwitchContext : public SavedStatusContext<ParserStatus::IN_SWITCH> {
@@ -515,7 +515,7 @@ template <typename T>
 class IterationContext : public SavedStatusContext<ParserStatus::IN_ITERATION> {
 public:
     explicit IterationContext(ParserContext *ctx, binder::Binder *binder)
-        : SavedStatusContext(ctx), lexicalScope_(binder)
+        : SavedStatusContext(ctx), lexical_scope_(binder)
     {
     }
 
@@ -525,23 +525,23 @@ public:
 
     const auto &LexicalScope() const
     {
-        return lexicalScope_;
+        return lexical_scope_;
     }
 
 private:
-    binder::LexicalScope<T> lexicalScope_;
+    binder::LexicalScope<T> lexical_scope_;
 };
 
 class FunctionParameterContext : public SavedStatusContext<ParserStatus::FUNCTION_PARAM> {
 public:
     explicit FunctionParameterContext(ParserContext *ctx, binder::Binder *binder)
-        : SavedStatusContext(ctx), lexicalScope_(binder)
+        : SavedStatusContext(ctx), lexical_scope_(binder)
     {
     }
 
     const auto &LexicalScope() const
     {
-        return lexicalScope_;
+        return lexical_scope_;
     }
 
     NO_COPY_SEMANTIC(FunctionParameterContext);
@@ -549,7 +549,7 @@ public:
     ~FunctionParameterContext() = default;
 
 private:
-    binder::LexicalScope<binder::FunctionParamScope> lexicalScope_;
+    binder::LexicalScope<binder::FunctionParamScope> lexical_scope_;
 };
 
 class SavedParserContext {
@@ -640,7 +640,7 @@ private:
 class SavedBindingsContext {
 public:
     explicit SavedBindingsContext(binder::Binder *binder)
-        : binder_(binder), savedBindings_(binder_->GetScope()->Bindings())
+        : binder_(binder), saved_bindings_(binder_->GetScope()->Bindings())
     {
     }
     NO_COPY_SEMANTIC(SavedBindingsContext);
@@ -654,7 +654,7 @@ protected:
     }
 
     binder::Binder *binder_;
-    binder::VariableMap savedBindings_;
+    binder::VariableMap saved_bindings_;
 };
 
 class ExportDeclarationContext : public SavedBindingsContext {
diff --git a/parser/program/program.cpp b/parser/program/program.cpp
index 42bee0341657f3772c677b0a7d8125ae637bbb4b..95775a906866a184a19ceee7abc7c87a6f2b8f9f 100644
--- a/parser/program/program.cpp
+++ b/parser/program/program.cpp
@@ -23,8 +23,8 @@ namespace panda::es2panda::parser {
 Program::Program(ScriptExtension extension)
     : allocator_(std::make_unique<ArenaAllocator>(SpaceType::SPACE_TYPE_COMPILER, nullptr, true)),
       binder_(allocator_->New<binder::Binder>(this)),
-      sourceCode_(Allocator()),
-      sourceFile_(Allocator()),
+      source_code_(Allocator()),
+      source_file_(Allocator()),
       extension_(extension)
 {
 }
@@ -33,8 +33,8 @@ Program::Program(Program &&other)
     : allocator_(std::move(other.allocator_)),
       binder_(other.binder_),
       ast_(other.ast_),
-      sourceCode_(other.sourceCode_),
-      sourceFile_(other.sourceFile_),
+      source_code_(other.source_code_),
+      source_file_(other.source_file_),
       kind_(other.kind_),
       extension_(other.extension_)
 {
@@ -47,8 +47,8 @@ Program &Program::operator=(Program &&other)
     allocator_ = std::move(other.allocator_);
     binder_ = other.binder_;
     ast_ = other.ast_;
-    sourceCode_ = other.sourceCode_;
-    sourceFile_ = other.sourceFile_;
+    source_code_ = other.source_code_;
+    source_file_ = other.source_file_;
     kind_ = other.kind_;
     extension_ = other.extension_;
 
diff --git a/parser/program/program.h b/parser/program/program.h
index 75f399e87988d0fc6d7a4887ee99d3a88de43c7a..7f23d473935cf434d707a6a59be20cb5982f3bbf 100644
--- a/parser/program/program.h
+++ b/parser/program/program.h
@@ -69,12 +69,12 @@ public:
 
     util::StringView SourceCode() const
     {
-        return sourceCode_.View();
+        return source_code_.View();
     }
 
     util::StringView SourceFile() const
     {
-        return sourceFile_.View();
+        return source_file_.View();
     }
 
     ir::BlockStatement *Ast()
@@ -94,8 +94,8 @@ public:
 
     void SetSource(const std::string &sourceCode, const std::string &sourceFile)
     {
-        sourceCode_ = util::UString(sourceCode, Allocator());
-        sourceFile_ = util::UString(sourceFile, Allocator());
+        source_code_ = util::UString(sourceCode, Allocator());
+        source_file_ = util::UString(sourceFile, Allocator());
     }
 
     std::string Dump() const;
@@ -105,8 +105,8 @@ private:
     std::unique_ptr<ArenaAllocator> allocator_ {};
     binder::Binder *binder_ {};
     ir::BlockStatement *ast_ {};
-    util::UString sourceCode_ {};
-    util::UString sourceFile_ {};
+    util::UString source_code_ {};
+    util::UString source_file_ {};
     ScriptKind kind_ {};
     ScriptExtension extension_ {};
 };
diff --git a/parser/statementParser.cpp b/parser/statementParser.cpp
index 2a06a84efb4e124c1b1a3521b5c7cc7e675ef83a..cba69dbb93fbab9069233b6fbe7a6575527507a2 100644
--- a/parser/statementParser.cpp
+++ b/parser/statementParser.cpp
@@ -1023,7 +1023,7 @@ ir::Statement *ParserImpl::ParseExpressionStatement(StatementParsingFlags flags)
             }
 
             ir::FunctionDeclaration *functionDecl = ParseFunctionDeclaration(false, ParserStatus::ASYNC_FUNCTION);
-            functionDecl->SetStart(startPos.token.Start());
+            functionDecl->SetStart(startPos.token_.Start());
 
             return functionDecl;
         }
@@ -1036,7 +1036,7 @@ ir::Statement *ParserImpl::ParseExpressionStatement(StatementParsingFlags flags)
     lexer::SourcePosition endPos = exprNode->End();
 
     auto *exprStatementNode = AllocNode<ir::ExpressionStatement>(exprNode);
-    exprStatementNode->SetRange({startPos.token.Start(), endPos});
+    exprStatementNode->SetRange({startPos.token_.Start(), endPos});
     ConsumeSemicolon(exprStatementNode);
 
     return exprStatementNode;
@@ -1363,28 +1363,28 @@ ir::IfStatement *ParserImpl::ParseIfStatement()
 
 ir::LabelledStatement *ParserImpl::ParseLabelledStatement(const lexer::LexerPosition &pos)
 {
-    const util::StringView &actualLabel = pos.token.Ident();
+    const util::StringView &actualLabel = pos.token_.Ident();
 
     // TODO(frobert) : check correctness
     if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_AWAIT && context_.IsModule()) {
-        ThrowSyntaxError("'await' is a reserved identifier in module code", pos.token.Start());
+        ThrowSyntaxError("'await' is a reserved identifier in module code", pos.token_.Start());
     }
 
     if (context_.FindLabel(actualLabel)) {
-        ThrowSyntaxError("Label already declared", pos.token.Start());
+        ThrowSyntaxError("Label already declared", pos.token_.Start());
     }
 
     SavedParserContext newCtx(this, ParserStatus::IN_LABELED, actualLabel);
 
     auto *identNode = AllocNode<ir::Identifier>(actualLabel, Allocator());
-    identNode->SetRange(pos.token.Loc());
+    identNode->SetRange(pos.token_.Loc());
 
     lexer_->NextToken();
 
     ir::Statement *body = ParseStatement(StatementParsingFlags::LABELLED);
 
     auto *labeledStatement = AllocNode<ir::LabelledStatement>(identNode, body);
-    labeledStatement->SetRange({pos.token.Start(), body->End()});
+    labeledStatement->SetRange({pos.token_.Start(), body->End()});
 
     return labeledStatement;
 }
diff --git a/patch1-all-es2panda.txt b/patch1-all-es2panda.txt
new file mode 100755
index 0000000000000000000000000000000000000000..335a814524ff119658742b8d9a5f540eb8141b57
--- /dev/null
+++ b/patch1-all-es2panda.txt
@@ -0,0 +1,11087 @@
+diff --git a/aot/main.cpp b/aot/main.cpp
+index 8dbd680..a647f00 100644
+--- a/aot/main.cpp
++++ b/aot/main.cpp
+@@ -130,7 +130,7 @@ int Run(int argc, const char **argv)
+         return err.ErrorCode();
+     }
+ 
+-    GenerateProgram(program, options->CompilerOutput(), options->OptLevel(), options->CompilerOptions().dumpAsm,
++    GenerateProgram(program, options->CompilerOutput(), options->OptLevel(), options->CompilerOptions().dump_asm_,
+                     options->SizeStat());
+     delete program;
+ 
+diff --git a/aot/options.cpp b/aot/options.cpp
+index 9be3f00..72b0a67 100644
+--- a/aot/options.cpp
++++ b/aot/options.cpp
+@@ -96,29 +96,29 @@ bool Options::Parse(int argc, const char **argv)
+         ss << "optional arguments:" << std::endl;
+         ss << argparser_->GetHelpString() << std::endl;
+ 
+-        errorMsg_ = ss.str();
++        error_msg_ = ss.str();
+         return false;
+     }
+ 
+-    sourceFile_ = inputFile.GetValue();
+-    std::ifstream inputStream(sourceFile_.c_str());
++    source_file_ = inputFile.GetValue();
++    std::ifstream inputStream(source_file_.c_str());
+ 
+     if (inputStream.fail()) {
+-        errorMsg_ = "Failed to open file: ";
+-        errorMsg_.append(sourceFile_);
++        error_msg_ = "Failed to open file: ";
++        error_msg_.append(source_file_);
+         return false;
+     }
+ 
+     std::stringstream ss;
+     ss << inputStream.rdbuf();
+-    parserInput_ = ss.str();
++    parser_input_ = ss.str();
+ 
+-    sourceFile_ = BaseName(sourceFile_);
++    source_file_ = BaseName(source_file_);
+ 
+     if (!outputFile.GetValue().empty()) {
+-        compilerOutput_ = outputFile.GetValue();
++        compiler_output_ = outputFile.GetValue();
+     } else {
+-        compilerOutput_ = RemoveExtension(sourceFile_).append(".abc");
++        compiler_output_ = RemoveExtension(source_file_).append(".abc");
+     }
+ 
+     std::string extension = inputExtension.GetValue();
+@@ -131,13 +131,13 @@ bool Options::Parse(int argc, const char **argv)
+         } else if (extension == "as") {
+             extension_ = es2panda::ScriptExtension::AS;
+         } else {
+-            errorMsg_ = "Invalid extension (available options: js, ts, as)";
++            error_msg_ = "Invalid extension (available options: js, ts, as)";
+             return false;
+         }
+     }
+ 
+-    optLevel_ = opOptLevel.GetValue();
+-    threadCount_ = opThreadCount.GetValue();
++    opt_level_ = opOptLevel.GetValue();
++    thread_count_ = opThreadCount.GetValue();
+ 
+     if (opParseOnly.GetValue()) {
+         options_ |= OptionFlags::PARSE_ONLY;
+@@ -151,11 +151,11 @@ bool Options::Parse(int argc, const char **argv)
+         options_ |= OptionFlags::SIZE_STAT;
+     }
+ 
+-    compilerOptions_.dumpAsm = opDumpAssembly.GetValue();
+-    compilerOptions_.dumpAst = opDumpAst.GetValue();
+-    compilerOptions_.dumpDebugInfo = opDumpDebugInfo.GetValue();
+-    compilerOptions_.isDebug = opDebugInfo.GetValue();
+-    compilerOptions_.parseOnly = opParseOnly.GetValue();
++    compiler_options_.dump_asm_ = opDumpAssembly.GetValue();
++    compiler_options_.dump_ast_ = opDumpAst.GetValue();
++    compiler_options_.dump_debug_info_ = opDumpDebugInfo.GetValue();
++    compiler_options_.is_debug_ = opDebugInfo.GetValue();
++    compiler_options_.parse_only_ = opParseOnly.GetValue();
+ 
+     return true;
+ }
+diff --git a/aot/options.h b/aot/options.h
+index af8c8e3..484c4b9 100644
+--- a/aot/options.h
++++ b/aot/options.h
+@@ -67,37 +67,37 @@ public:
+ 
+     const es2panda::CompilerOptions &CompilerOptions() const
+     {
+-        return compilerOptions_;
++        return compiler_options_;
+     }
+ 
+     const std::string &ParserInput() const
+     {
+-        return parserInput_;
++        return parser_input_;
+     }
+ 
+     const std::string &CompilerOutput() const
+     {
+-        return compilerOutput_;
++        return compiler_output_;
+     }
+ 
+     const std::string &SourceFile() const
+     {
+-        return sourceFile_;
++        return source_file_;
+     }
+ 
+     const std::string &ErrorMsg() const
+     {
+-        return errorMsg_;
++        return error_msg_;
+     }
+ 
+     int OptLevel() const
+     {
+-        return optLevel_;
++        return opt_level_;
+     }
+ 
+     int ThreadCount() const
+     {
+-        return threadCount_;
++        return thread_count_;
+     }
+ 
+     bool ParseModule() const
+@@ -117,16 +117,16 @@ public:
+ 
+ private:
+     es2panda::ScriptExtension extension_ {es2panda::ScriptExtension::JS};
+-    es2panda::CompilerOptions compilerOptions_ {};
++    es2panda::CompilerOptions compiler_options_ {};
+     OptionFlags options_ {OptionFlags::DEFAULT};
+     panda::PandArgParser *argparser_;
+-    std::string parserInput_;
+-    std::string compilerOutput_;
++    std::string parser_input_;
++    std::string compiler_output_;
+     std::string result_;
+-    std::string sourceFile_;
+-    std::string errorMsg_;
+-    int optLevel_ {0};
+-    int threadCount_ {0};
++    std::string source_file_;
++    std::string error_msg_;
++    int opt_level_ {0};
++    int thread_count_ {0};
+ };
+ 
+ }  // namespace panda::es2panda::aot
+diff --git a/binder/binder.cpp b/binder/binder.cpp
+index d2a8b2a..9ffe0fa 100644
+--- a/binder/binder.cpp
++++ b/binder/binder.cpp
+@@ -45,12 +45,12 @@ namespace panda::es2panda::binder {
+ void Binder::InitTopScope()
+ {
+     if (program_->Kind() == parser::ScriptKind::MODULE) {
+-        topScope_ = Allocator()->New<ModuleScope>(Allocator());
++        top_scope_ = Allocator()->New<ModuleScope>(Allocator());
+     } else {
+-        topScope_ = Allocator()->New<GlobalScope>(Allocator());
++        top_scope_ = Allocator()->New<GlobalScope>(Allocator());
+     }
+ 
+-    scope_ = topScope_;
++    scope_ = top_scope_;
+ }
+ 
+ ParameterDecl *Binder::AddParamDecl(const ir::AstNode *param)
+@@ -72,15 +72,15 @@ void Binder::ThrowRedeclaration(const lexer::SourcePosition &pos, const util::St
+ 
+     std::stringstream ss;
+     ss << "Variable '" << name << "' has already been declared.";
+-    throw Error(ErrorType::SYNTAX, ss.str(), loc.line, loc.col);
++    throw Error(ErrorType::SYNTAX, ss.str(), loc.line_, loc.col_);
+ }
+ 
+ void Binder::IdentifierAnalysis()
+ {
+     ASSERT(program_->Ast());
+-    ASSERT(scope_ == topScope_);
++    ASSERT(scope_ == top_scope_);
+ 
+-    BuildFunction(topScope_, "main");
++    BuildFunction(top_scope_, "main");
+     ResolveReferences(program_->Ast());
+     AddMandatoryParams();
+ }
+@@ -88,12 +88,12 @@ void Binder::IdentifierAnalysis()
+ void Binder::LookupReference(const util::StringView &name)
+ {
+     ScopeFindResult res = scope_->Find(name);
+-    if (res.level == 0) {
++    if (res.level_ == 0) {
+         return;
+     }
+ 
+-    ASSERT(res.variable);
+-    res.variable->SetLexical(res.scope);
++    ASSERT(res.variable_);
++    res.variable_->SetLexical(res.scope_);
+ }
+ 
+ void Binder::InstantiateArguments()
+@@ -142,26 +142,26 @@ void Binder::LookupIdentReference(ir::Identifier *ident)
+     }
+ 
+     ScopeFindResult res = scope_->Find(ident->Name());
+-    if (res.level != 0) {
+-        ASSERT(res.variable);
+-        res.variable->SetLexical(res.scope);
++    if (res.level_ != 0) {
++        ASSERT(res.variable_);
++        res.variable_->SetLexical(res.scope_);
+     }
+ 
+-    if (!res.variable) {
++    if (!res.variable_) {
+         return;
+     }
+ 
+-    if (res.variable->Declaration()->IsLetOrConstDecl() && !res.variable->HasFlag(VariableFlags::INITIALIZED)) {
++    if (res.variable_->Declaration()->IsLetOrConstDecl() && !res.variable_->HasFlag(VariableFlags::INITIALIZED)) {
+         ident->SetTdz();
+     }
+ 
+-    ident->SetVariable(res.variable);
++    ident->SetVariable(res.variable_);
+ }
+ 
+ void Binder::BuildFunction(FunctionScope *funcScope, util::StringView name)
+ {
+-    uint32_t idx = functionScopes_.size();
+-    functionScopes_.push_back(funcScope);
++    uint32_t idx = function_scopes_.size();
++    function_scopes_.push_back(funcScope);
+ 
+     std::stringstream ss;
+     ss << "func_" << name << "_" << std::to_string(idx);
+@@ -245,8 +245,8 @@ void Binder::BuildClassDefinition(ir::ClassDefinition *classDef)
+     if (classDef->Parent()->IsClassDeclaration()) {
+         ScopeFindResult res = scope_->Find(classDef->Ident()->Name());
+ 
+-        ASSERT(res.variable && res.variable->Declaration()->IsLetDecl());
+-        res.variable->AddFlag(VariableFlags::INITIALIZED);
++        ASSERT(res.variable_ && res.variable_->Declaration()->IsLetDecl());
++        res.variable_->AddFlag(VariableFlags::INITIALIZED);
+     }
+ 
+     auto scopeCtx = LexicalScope<LocalScope>::Enter(this, classDef->Scope());
+@@ -258,8 +258,8 @@ void Binder::BuildClassDefinition(ir::ClassDefinition *classDef)
+     if (classDef->Ident()) {
+         ScopeFindResult res = scope_->Find(classDef->Ident()->Name());
+ 
+-        ASSERT(res.variable && res.variable->Declaration()->IsConstDecl());
+-        res.variable->AddFlag(VariableFlags::INITIALIZED);
++        ASSERT(res.variable_ && res.variable_->Declaration()->IsConstDecl());
++        res.variable_->AddFlag(VariableFlags::INITIALIZED);
+     }
+ 
+     ResolveReference(classDef, classDef->Ctor());
+@@ -462,15 +462,15 @@ void Binder::AddMandatoryParams(const MandatoryParams &params)
+ 
+ void Binder::AddMandatoryParams()
+ {
+-    ASSERT(scope_ == topScope_);
+-    ASSERT(!functionScopes_.empty());
+-    auto iter = functionScopes_.begin();
++    ASSERT(scope_ == top_scope_);
++    ASSERT(!function_scopes_.empty());
++    auto iter = function_scopes_.begin();
+     [[maybe_unused]] auto *funcScope = *iter++;
+ 
+     ASSERT(funcScope->IsGlobalScope() || funcScope->IsModuleScope());
+     AddMandatoryParams(FUNCTION_MANDATORY_PARAMS);
+ 
+-    for (; iter != functionScopes_.end(); iter++) {
++    for (; iter != function_scopes_.end(); iter++) {
+         funcScope = *iter;
+         const auto *scriptFunc = funcScope->Node()->AsScriptFunction();
+ 
+diff --git a/binder/binder.h b/binder/binder.h
+index 10d52ef..f5325e9 100644
+--- a/binder/binder.h
++++ b/binder/binder.h
+@@ -41,7 +41,7 @@ class VariableScope;
+ 
+ class Binder {
+ public:
+-    explicit Binder(parser::Program *program) : program_(program), functionScopes_(Allocator()->Adapter()) {}
++    explicit Binder(parser::Program *program) : program_(program), function_scopes_(Allocator()->Adapter()) {}
+     NO_COPY_SEMANTIC(Binder);
+     DEFAULT_MOVE_SEMANTIC(Binder);
+     ~Binder() = default;
+@@ -64,7 +64,7 @@ public:
+ 
+     GlobalScope *TopScope() const
+     {
+-        return topScope_;
++        return top_scope_;
+     }
+ 
+     [[noreturn]] void ThrowRedeclaration(const lexer::SourcePosition &pos, const util::StringView &name);
+@@ -79,12 +79,12 @@ public:
+ 
+     const ArenaVector<FunctionScope *> &Functions() const
+     {
+-        return functionScopes_;
++        return function_scopes_;
+     }
+ 
+     ArenaVector<FunctionScope *> Functions()
+     {
+-        return functionScopes_;
++        return function_scopes_;
+     }
+ 
+     const parser::Program *Program() const
+@@ -135,9 +135,9 @@ private:
+     void ResolveReferences(const ir::AstNode *parent);
+ 
+     parser::Program *program_ {};
+-    GlobalScope *topScope_ {};
++    GlobalScope *top_scope_ {};
+     Scope *scope_ {};
+-    ArenaVector<FunctionScope *> functionScopes_;
++    ArenaVector<FunctionScope *> function_scopes_;
+ };
+ 
+ template <typename T>
+@@ -158,7 +158,7 @@ public:
+     ~LexicalScope()
+     {
+         ASSERT(binder_);
+-        binder_->scope_ = prevScope_;
++        binder_->scope_ = prev_scope_;
+     }
+ 
+     [[nodiscard]] static LexicalScope<T> Enter(Binder *binder, T *scope)
+@@ -172,14 +172,14 @@ public:
+ private:
+     NO_COPY_SEMANTIC(LexicalScope);
+ 
+-    explicit LexicalScope(T *scope, Binder *binder) : binder_(binder), scope_(scope), prevScope_(binder->scope_)
++    explicit LexicalScope(T *scope, Binder *binder) : binder_(binder), scope_(scope), prev_scope_(binder->scope_)
+     {
+         binder_->scope_ = scope_;
+     }
+ 
+     Binder *binder_ {};
+     T *scope_ {};
+-    Scope *prevScope_ {};
++    Scope *prev_scope_ {};
+ };
+ 
+ template <typename T, typename... Args>
+diff --git a/binder/declaration.h b/binder/declaration.h
+index ab65a75..0383e0e 100644
+--- a/binder/declaration.h
++++ b/binder/declaration.h
+@@ -113,7 +113,7 @@ private:
+ 
+ class EnumLiteralDecl : public Decl {
+ public:
+-    explicit EnumLiteralDecl(util::StringView name, bool isConst) : Decl(name), isConst_(isConst) {}
++    explicit EnumLiteralDecl(util::StringView name, bool isConst) : Decl(name), is_const_(isConst) {}
+ 
+     DeclType Type() const override
+     {
+@@ -122,7 +122,7 @@ public:
+ 
+     bool IsConst() const
+     {
+-        return isConst_;
++        return is_const_;
+     }
+ 
+     void BindScope(LocalScope *scope)
+@@ -137,7 +137,7 @@ public:
+ 
+ private:
+     LocalScope *scope_ {};
+-    bool isConst_ {};
++    bool is_const_ {};
+ };
+ 
+ class InterfaceDecl : public MultiDecl<ir::TSInterfaceDeclaration> {
+@@ -247,19 +247,19 @@ public:
+ class ImportDecl : public Decl {
+ public:
+     explicit ImportDecl(util::StringView importName, util::StringView localName)
+-        : Decl(localName), importName_(importName)
++        : Decl(localName), import_name_(importName)
+     {
+     }
+ 
+     explicit ImportDecl(util::StringView importName, util::StringView localName, const ir::AstNode *node)
+-        : Decl(localName), importName_(importName)
++        : Decl(localName), import_name_(importName)
+     {
+         BindNode(node);
+     }
+ 
+     const util::StringView &ImportName() const
+     {
+-        return importName_;
++        return import_name_;
+     }
+ 
+     const util::StringView &LocalName() const
+@@ -273,25 +273,25 @@ public:
+     }
+ 
+ private:
+-    util::StringView importName_;
++    util::StringView import_name_;
+ };
+ 
+ class ExportDecl : public Decl {
+ public:
+     explicit ExportDecl(util::StringView exportName, util::StringView localName)
+-        : Decl(localName), exportName_(exportName)
++        : Decl(localName), export_name_(exportName)
+     {
+     }
+ 
+     explicit ExportDecl(util::StringView exportName, util::StringView localName, const ir::AstNode *node)
+-        : Decl(localName), exportName_(exportName)
++        : Decl(localName), export_name_(exportName)
+     {
+         BindNode(node);
+     }
+ 
+     const util::StringView &ExportName() const
+     {
+-        return exportName_;
++        return export_name_;
+     }
+ 
+     const util::StringView &LocalName() const
+@@ -305,7 +305,7 @@ public:
+     }
+ 
+ private:
+-    util::StringView exportName_;
++    util::StringView export_name_;
+ };
+ 
+ }  // namespace panda::es2panda::binder
+diff --git a/binder/scope.cpp b/binder/scope.cpp
+index 402bdd7..39cf92b 100644
+--- a/binder/scope.cpp
++++ b/binder/scope.cpp
+@@ -237,8 +237,8 @@ std::tuple<ParameterDecl *, const ir::AstNode *> ParamScope::AddParamDecl(ArenaA
+ 
+ void FunctionParamScope::BindName(ArenaAllocator *allocator, util::StringView name)
+ {
+-    nameVar_ = AddDecl<ConstDecl, LocalVariable>(allocator, name, VariableFlags::INITIALIZED);
+-    functionScope_->Bindings().insert({name, nameVar_});
++    name_var_ = AddDecl<ConstDecl, LocalVariable>(allocator, name, VariableFlags::INITIALIZED);
++    function_scope_->Bindings().insert({name, name_var_});
+ }
+ 
+ bool FunctionParamScope::AddBinding([[maybe_unused]] ArenaAllocator *allocator,
+@@ -421,7 +421,7 @@ bool ModuleScope::ExportAnalysis()
+ 
+             if (!variable->IsModuleVariable()) {
+                 variable->AddFlag(VariableFlags::LOCAL_EXPORT);
+-                localExports_.insert({variable, decl->ExportName()});
++                local_exports_.insert({variable, decl->ExportName()});
+             }
+         }
+     }
+@@ -448,41 +448,41 @@ void LoopDeclarationScope::ConvertToVariableScope(ArenaAllocator *allocator)
+             continue;
+         }
+ 
+-        slotIndex_++;
+-        loopType_ = ScopeType::LOOP_DECL;
++        slot_index_++;
++        loop_type_ = ScopeType::LOOP_DECL;
+         auto *copiedVar = var->AsLocalVariable()->Copy(allocator, var->Declaration());
+         copiedVar->AddFlag(VariableFlags::INITIALIZED | VariableFlags::PER_ITERATION);
+         var->AddFlag(VariableFlags::LOOP_DECL);
+-        loopScope_->Bindings().insert({name, copiedVar});
++        loop_scope_->Bindings().insert({name, copiedVar});
+     }
+ 
+-    if (loopType_ == ScopeType::LOOP_DECL) {
+-        slotIndex_ = std::max(slotIndex_, parent_->EnclosingVariableScope()->LexicalSlots());
+-        initScope_ = allocator->New<LocalScope>(allocator, parent_);
+-        initScope_->BindNode(node_);
+-        initScope_->Bindings() = bindings_;
++    if (loop_type_ == ScopeType::LOOP_DECL) {
++        slot_index_ = std::max(slot_index_, parent_->EnclosingVariableScope()->LexicalSlots());
++        init_scope_ = allocator->New<LocalScope>(allocator, parent_);
++        init_scope_->BindNode(node_);
++        init_scope_->Bindings() = bindings_;
+     }
+ }
+ 
+ void LoopScope::ConvertToVariableScope(ArenaAllocator *allocator)
+ {
+-    declScope_->ConvertToVariableScope(allocator);
++    decl_scope_->ConvertToVariableScope(allocator);
+ 
+-    if (loopType_ != ScopeType::LOCAL) {
++    if (loop_type_ != ScopeType::LOCAL) {
+         return;
+     }
+ 
+     for (const auto &[_, var] : bindings_) {
+         (void)_;
+         if (var->LexicalBound() && var->Declaration()->IsLetDecl()) {
+-            ASSERT(declScope_->NeedLexEnv());
+-            loopType_ = ScopeType::LOOP;
++            ASSERT(decl_scope_->NeedLexEnv());
++            loop_type_ = ScopeType::LOOP;
+             break;
+         }
+     }
+ 
+-    if (loopType_ == ScopeType::LOOP) {
+-        slotIndex_ = std::max(slotIndex_, declScope_->LexicalSlots());
++    if (loop_type_ == ScopeType::LOOP) {
++        slot_index_ = std::max(slot_index_, decl_scope_->LexicalSlots());
+     }
+ }
+ 
+@@ -495,7 +495,7 @@ bool CatchParamScope::AddBinding(ArenaAllocator *allocator, Variable *currentVar
+ bool CatchScope::AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+                             [[maybe_unused]] ScriptExtension extension)
+ {
+-    if (!newDecl->IsVarDecl() && paramScope_->FindLocal(newDecl->Name())) {
++    if (!newDecl->IsVarDecl() && param_scope_->FindLocal(newDecl->Name())) {
+         return false;
+     }
+ 
+diff --git a/binder/scope.h b/binder/scope.h
+index 881abfb..611a3ca 100644
+--- a/binder/scope.h
++++ b/binder/scope.h
+@@ -46,17 +46,19 @@ class ScopeFindResult {
+ public:
+     ScopeFindResult() = default;
+     ScopeFindResult(util::StringView n, Scope *s, uint32_t l, Variable *v) : ScopeFindResult(n, s, l, l, v) {}
+-    ScopeFindResult(Scope *s, uint32_t l, uint32_t ll, Variable *v) : scope(s), level(l), lexLevel(ll), variable(v) {}
++    ScopeFindResult(Scope *s, uint32_t l, uint32_t ll, Variable *v) : scope_(s), level_(l), lex_level_(ll), variable_(v)
++    {
++    }
+     ScopeFindResult(util::StringView n, Scope *s, uint32_t l, uint32_t ll, Variable *v)
+-        : name(n), scope(s), level(l), lexLevel(ll), variable(v)
++        : name_(n), scope_(s), level_(l), lex_level_(ll), variable_(v)
+     {
+     }
+ 
+-    util::StringView name {};
+-    Scope *scope {};
+-    uint32_t level {};
+-    uint32_t lexLevel {};
+-    Variable *variable {};
++    util::StringView name_ {};
++    Scope *scope_ {};
++    uint32_t level_ {};
++    uint32_t lex_level_ {};
++    Variable *variable_ {};
+ };
+ 
+ class Scope {
+@@ -138,22 +140,22 @@ public:
+ 
+     const compiler::IRNode *ScopeStart() const
+     {
+-        return startIns_;
++        return start_ins_;
+     }
+ 
+     const compiler::IRNode *ScopeEnd() const
+     {
+-        return endIns_;
++        return end_ins_;
+     }
+ 
+     void SetScopeStart(const compiler::IRNode *ins)
+     {
+-        startIns_ = ins;
++        start_ins_ = ins;
+     }
+ 
+     void SetScopeEnd(const compiler::IRNode *ins)
+     {
+-        endIns_ = ins;
++        end_ins_ = ins;
+     }
+ 
+     const ir::AstNode *Node() const
+@@ -237,8 +239,8 @@ protected:
+     ArenaVector<Decl *> decls_;
+     VariableMap bindings_;
+     const ir::AstNode *node_ {};
+-    const compiler::IRNode *startIns_ {};
+-    const compiler::IRNode *endIns_ {};
++    const compiler::IRNode *start_ins_ {};
++    const compiler::IRNode *end_ins_ {};
+ };
+ 
+ class VariableScope : public Scope {
+@@ -264,17 +266,17 @@ public:
+ 
+     uint32_t NextSlot()
+     {
+-        return slotIndex_++;
++        return slot_index_++;
+     }
+ 
+     uint32_t LexicalSlots() const
+     {
+-        return slotIndex_;
++        return slot_index_;
+     }
+ 
+     bool NeedLexEnv() const
+     {
+-        return slotIndex_ != 0;
++        return slot_index_ != 0;
+     }
+ 
+ protected:
+@@ -294,7 +296,7 @@ protected:
+     bool AddLexical(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl);
+ 
+     VariableScopeFlags flags_ {};
+-    uint32_t slotIndex_ {};
++    uint32_t slot_index_ {};
+ };
+ 
+ class ParamScope : public Scope {
+@@ -335,17 +337,17 @@ public:
+ 
+     FunctionScope *GetFunctionScope() const
+     {
+-        return functionScope_;
++        return function_scope_;
+     }
+ 
+     void BindFunctionScope(FunctionScope *funcScope)
+     {
+-        functionScope_ = funcScope;
++        function_scope_ = funcScope;
+     }
+ 
+     LocalVariable *NameVar() const
+     {
+-        return nameVar_;
++        return name_var_;
+     }
+ 
+     void BindName(ArenaAllocator *allocator, util::StringView name);
+@@ -363,8 +365,8 @@ public:
+     friend class ScopeWithParamScope;
+ 
+ private:
+-    FunctionScope *functionScope_ {};
+-    LocalVariable *nameVar_ {};
++    FunctionScope *function_scope_ {};
++    LocalVariable *name_var_ {};
+ };
+ 
+ template <typename E, typename T>
+@@ -383,21 +385,21 @@ public:
+         ASSERT(this->parent_ == paramScope);
+         ASSERT(this->bindings_.empty());
+ 
+-        paramScope_ = paramScope;
++        param_scope_ = paramScope;
+     }
+ 
+     T *ParamScope()
+     {
+-        return paramScope_;
++        return param_scope_;
+     }
+ 
+     const T *ParamScope() const
+     {
+-        return paramScope_;
++        return param_scope_;
+     }
+ 
+ protected:
+-    T *paramScope_;
++    T *param_scope_;
+ };
+ 
+ class FunctionScope : public ScopeWithParamScope<VariableScope, FunctionParamScope> {
+@@ -412,7 +414,7 @@ public:
+     void BindName(util::StringView name, util::StringView internalName)
+     {
+         name_ = name;
+-        internalName_ = internalName;
++        internal_name_ = internalName;
+     }
+ 
+     const util::StringView &Name() const
+@@ -422,7 +424,7 @@ public:
+ 
+     const util::StringView &InternalName() const
+     {
+-        return internalName_;
++        return internal_name_;
+     }
+ 
+     bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+@@ -430,7 +432,7 @@ public:
+ 
+ private:
+     util::StringView name_ {};
+-    util::StringView internalName_ {};
++    util::StringView internal_name_ {};
+ };
+ 
+ class LocalScope : public Scope {
+@@ -482,7 +484,7 @@ public:
+ 
+     ScopeType Type() const override
+     {
+-        return loopType_;
++        return loop_type_;
+     }
+ 
+     bool AddBinding(ArenaAllocator *allocator, Variable *currentVariable, Decl *newDecl,
+@@ -494,7 +496,7 @@ public:
+     Scope *InitScope()
+     {
+         if (NeedLexEnv()) {
+-            return initScope_;
++            return init_scope_;
+         }
+ 
+         return this;
+@@ -504,9 +506,9 @@ public:
+ 
+ private:
+     friend class LoopScope;
+-    LoopScope *loopScope_ {};
+-    LocalScope *initScope_ {};
+-    ScopeType loopType_ {ScopeType::LOCAL};
++    LoopScope *loop_scope_ {};
++    LocalScope *init_scope_ {};
++    ScopeType loop_type_ {ScopeType::LOCAL};
+ };
+ 
+ class LoopScope : public VariableScope {
+@@ -515,18 +517,18 @@ public:
+ 
+     LoopDeclarationScope *DeclScope()
+     {
+-        return declScope_;
++        return decl_scope_;
+     }
+ 
+     void BindDecls(LoopDeclarationScope *declScope)
+     {
+-        declScope_ = declScope;
+-        declScope_->loopScope_ = this;
++        decl_scope_ = declScope;
++        decl_scope_->loop_scope_ = this;
+     }
+ 
+     ScopeType Type() const override
+     {
+-        return loopType_;
++        return loop_type_;
+     }
+ 
+     void ConvertToVariableScope(ArenaAllocator *allocator);
+@@ -538,8 +540,8 @@ public:
+     }
+ 
+ protected:
+-    LoopDeclarationScope *declScope_ {};
+-    ScopeType loopType_ {ScopeType::LOCAL};
++    LoopDeclarationScope *decl_scope_ {};
++    ScopeType loop_type_ {ScopeType::LOCAL};
+ };
+ 
+ class GlobalScope : public FunctionScope {
+@@ -547,7 +549,7 @@ public:
+     explicit GlobalScope(ArenaAllocator *allocator) : FunctionScope(allocator, nullptr)
+     {
+         auto *paramScope = allocator->New<FunctionParamScope>(allocator, this);
+-        paramScope_ = paramScope;
++        param_scope_ = paramScope;
+     }
+ 
+     ScopeType Type() const override
+@@ -572,7 +574,7 @@ public:
+           allocator_(allocator),
+           imports_(allocator_->Adapter()),
+           exports_(allocator_->Adapter()),
+-          localExports_(allocator_->Adapter())
++          local_exports_(allocator_->Adapter())
+     {
+     }
+ 
+@@ -593,7 +595,7 @@ public:
+ 
+     const LocalExportNameMap &LocalExports() const
+     {
+-        return localExports_;
++        return local_exports_;
+     }
+ 
+     void AddImportDecl(const ir::ImportDeclaration *importDecl, ImportDeclList &&decls);
+@@ -613,7 +615,7 @@ private:
+     ArenaAllocator *allocator_;
+     ModuleEntry<const ir::ImportDeclaration *, ImportDeclList> imports_;
+     ModuleEntry<const ir::AstNode *, ExportDeclList> exports_;
+-    LocalExportNameMap localExports_;
++    LocalExportNameMap local_exports_;
+ };
+ 
+ template <typename T>
+diff --git a/binder/variable.h b/binder/variable.h
+index 4302048..d65a5d6 100644
+--- a/binder/variable.h
++++ b/binder/variable.h
+@@ -76,12 +76,12 @@ public:
+ 
+     checker::Type *TsType() const
+     {
+-        return tsType_;
++        return ts_type_;
+     }
+ 
+     void SetTsType(checker::Type *tsType)
+     {
+-        tsType_ = tsType;
++        ts_type_ = tsType;
+     }
+ 
+     void AddFlag(VariableFlags flag)
+@@ -118,7 +118,7 @@ protected:
+ 
+     Decl *decl_;
+     VariableFlags flags_ {};
+-    checker::Type *tsType_ {};
++    checker::Type *ts_type_ {};
+ };
+ 
+ class LocalVariable : public Variable {
+@@ -184,35 +184,35 @@ public:
+ 
+     compiler::VReg &ModuleReg()
+     {
+-        return moduleReg_;
++        return module_reg_;
+     }
+ 
+     compiler::VReg ModuleReg() const
+     {
+-        return moduleReg_;
++        return module_reg_;
+     }
+ 
+     const util::StringView &ExoticName() const
+     {
+-        return exoticName_;
++        return exotic_name_;
+     }
+ 
+     util::StringView &ExoticName()
+     {
+-        return exoticName_;
++        return exotic_name_;
+     }
+ 
+     void SetLexical([[maybe_unused]] Scope *scope) override;
+ 
+ private:
+-    compiler::VReg moduleReg_ {};
+-    util::StringView exoticName_ {};
++    compiler::VReg module_reg_ {};
++    util::StringView exotic_name_ {};
+ };
+ 
+ class EnumVariable : public Variable {
+ public:
+     explicit EnumVariable(Decl *decl, bool backReference = false)
+-        : Variable(decl, VariableFlags::NONE), backReference_(backReference)
++        : Variable(decl, VariableFlags::NONE), back_reference_(backReference)
+     {
+     }
+ 
+@@ -233,12 +233,12 @@ public:
+ 
+     bool BackReference() const
+     {
+-        return backReference_;
++        return back_reference_;
+     }
+ 
+     void SetBackReference()
+     {
+-        backReference_ = true;
++        back_reference_ = true;
+     }
+ 
+     void ResetDecl(Decl *decl);
+@@ -247,7 +247,7 @@ public:
+ 
+ private:
+     EnumMemberResult value_ {false};
+-    bool backReference_ {};
++    bool back_reference_ {};
+ };
+ 
+ }  // namespace panda::es2panda::binder
+diff --git a/compiler/base/catchTable.h b/compiler/base/catchTable.h
+index 9954ae9..faf7f47 100644
+--- a/compiler/base/catchTable.h
++++ b/compiler/base/catchTable.h
+@@ -68,7 +68,7 @@ private:
+ 
+ class CatchTable {
+ public:
+-    CatchTable(PandaGen *pg, uint32_t depth) : labelSet_(pg), depth_(depth) {}
++    CatchTable(PandaGen *pg, uint32_t depth) : label_set_(pg), depth_(depth) {}
+ 
+     ~CatchTable() = default;
+     NO_COPY_SEMANTIC(CatchTable);
+@@ -76,7 +76,7 @@ public:
+ 
+     const TryLabelSet &LabelSet() const
+     {
+-        return labelSet_;
++        return label_set_;
+     }
+ 
+     uint32_t Depth() const
+@@ -85,7 +85,7 @@ public:
+     }
+ 
+ private:
+-    TryLabelSet labelSet_;
++    TryLabelSet label_set_;
+     uint32_t depth_;
+ };
+ 
+diff --git a/compiler/base/iterators.cpp b/compiler/base/iterators.cpp
+index 1bf7ad8..8224c2f 100644
+--- a/compiler/base/iterators.cpp
++++ b/compiler/base/iterators.cpp
+@@ -24,7 +24,12 @@ namespace panda::es2panda::compiler {
+ // Iterator
+ 
+ Iterator::Iterator(PandaGen *pg, const ir::AstNode *node, IteratorType type)
+-    : pg_(pg), node_(node), method_(pg->AllocReg()), iterator_(pg->AllocReg()), nextResult_(pg->AllocReg()), type_(type)
++    : pg_(pg),
++      node_(node),
++      method_(pg->AllocReg()),
++      iterator_(pg->AllocReg()),
++      next_result_(pg->AllocReg()),
++      type_(type)
+ {
+     if (type_ == IteratorType::ASYNC) {
+         pg_->GetAsyncIterator(node);
+@@ -64,18 +69,18 @@ void Iterator::Next() const
+     }
+ 
+     pg_->ThrowIfNotObject(node_);
+-    pg_->StoreAccumulator(node_, nextResult_);
++    pg_->StoreAccumulator(node_, next_result_);
+ }
+ 
+ void Iterator::Complete() const
+ {
+-    pg_->LoadObjByName(node_, nextResult_, "done");
++    pg_->LoadObjByName(node_, next_result_, "done");
+     pg_->ToBoolean(node_);
+ }
+ 
+ void Iterator::Value() const
+ {
+-    pg_->LoadObjByName(node_, nextResult_, "value");
++    pg_->LoadObjByName(node_, next_result_, "value");
+ }
+ 
+ void Iterator::Close(bool abruptCompletion) const
+diff --git a/compiler/base/iterators.h b/compiler/base/iterators.h
+index 0f23818..ed1db0a 100644
+--- a/compiler/base/iterators.h
++++ b/compiler/base/iterators.h
+@@ -47,7 +47,7 @@ public:
+ 
+     VReg NextResult() const
+     {
+-        return nextResult_;
++        return next_result_;
+     }
+ 
+     const ir::AstNode *Node() const
+@@ -70,7 +70,7 @@ protected:
+     // These 3 regs must be allocated continously
+     VReg method_;
+     VReg iterator_;
+-    VReg nextResult_;
++    VReg next_result_;
+     IteratorType type_;
+ };
+ 
+diff --git a/compiler/base/lexenv.cpp b/compiler/base/lexenv.cpp
+index f3410f0..21470e7 100644
+--- a/compiler/base/lexenv.cpp
++++ b/compiler/base/lexenv.cpp
+@@ -43,13 +43,13 @@ static void CheckConstAssignment(PandaGen *pg, const ir::AstNode *node, binder::
+ 
+ static void ExpandLoadLexVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result)
+ {
+-    pg->LoadLexicalVar(node, result.lexLevel, result.variable->AsLocalVariable()->LexIdx());
+-    pg->ThrowUndefinedIfHole(node, result.variable->Name());
++    pg->LoadLexicalVar(node, result.lex_level_, result.variable_->AsLocalVariable()->LexIdx());
++    pg->ThrowUndefinedIfHole(node, result.variable_->Name());
+ }
+ 
+ static void ExpandLoadNormalVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result)
+ {
+-    auto *local = result.variable->AsLocalVariable();
++    auto *local = result.variable_->AsLocalVariable();
+ 
+     if (CheckTdz(node)) {
+         pg->LoadConst(node, Constant::JS_HOLE);
+@@ -61,7 +61,7 @@ static void ExpandLoadNormalVar(PandaGen *pg, const ir::AstNode *node, const bin
+ 
+ void VirtualLoadVar::Expand(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result)
+ {
+-    if (result.variable->LexicalBound()) {
++    if (result.variable_->LexicalBound()) {
+         ExpandLoadLexVar(pg, node, result);
+     } else {
+         ExpandLoadNormalVar(pg, node, result);
+@@ -87,9 +87,9 @@ static void StoreLocalExport(PandaGen *pg, const ir::AstNode *node, binder::Vari
+ 
+ static void ExpandStoreLexVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDecl)
+ {
+-    binder::LocalVariable *local = result.variable->AsLocalVariable();
++    binder::LocalVariable *local = result.variable_->AsLocalVariable();
+ 
+-    const auto *decl = result.variable->Declaration();
++    const auto *decl = result.variable_->Declaration();
+ 
+     if (decl->IsLetOrConstDecl() && !isDecl) {
+         RegScope rs(pg);
+@@ -106,7 +106,7 @@ static void ExpandStoreLexVar(PandaGen *pg, const ir::AstNode *node, const binde
+         pg->LoadAccumulator(node, valueReg);
+     }
+ 
+-    pg->StoreLexicalVar(node, result.lexLevel, local->LexIdx());
++    pg->StoreLexicalVar(node, result.lex_level_, local->LexIdx());
+ 
+     StoreLocalExport(pg, node, local);
+ }
+@@ -114,7 +114,7 @@ static void ExpandStoreLexVar(PandaGen *pg, const ir::AstNode *node, const binde
+ static void ExpandStoreNormalVar(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result,
+                                  bool isDecl)
+ {
+-    auto *local = result.variable->AsLocalVariable();
++    auto *local = result.variable_->AsLocalVariable();
+     VReg localReg = local->Vreg();
+ 
+     if (!isDecl) {
+@@ -132,7 +132,7 @@ static void ExpandStoreNormalVar(PandaGen *pg, const ir::AstNode *node, const bi
+ 
+ void VirtualStoreVar::Expand(PandaGen *pg, const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDecl)
+ {
+-    if (result.variable->LexicalBound()) {
++    if (result.variable_->LexicalBound()) {
+         ExpandStoreLexVar(pg, node, result, isDecl);
+     } else {
+         ExpandStoreNormalVar(pg, node, result, isDecl);
+diff --git a/compiler/base/lreference.cpp b/compiler/base/lreference.cpp
+index 6fd21e1..0920305 100644
+--- a/compiler/base/lreference.cpp
++++ b/compiler/base/lreference.cpp
+@@ -31,7 +31,7 @@ namespace panda::es2panda::compiler {
+ 
+ LReference::LReference(const ir::AstNode *node, PandaGen *pg, bool isDeclaration, ReferenceKind refKind,
+                        binder::ScopeFindResult res)
+-    : node_(node), pg_(pg), refKind_(refKind), res_(res), isDeclaration_(isDeclaration)
++    : node_(node), pg_(pg), ref_kind_(refKind), res_(res), is_declaration_(isDeclaration)
+ {
+     if (refKind == ReferenceKind::MEMBER) {
+         obj_ = pg_->AllocReg();
+@@ -43,7 +43,7 @@ LReference::LReference(const ir::AstNode *node, PandaGen *pg, bool isDeclaration
+ 
+ void LReference::GetValue()
+ {
+-    switch (refKind_) {
++    switch (ref_kind_) {
+         case ReferenceKind::VAR_OR_GLOBAL: {
+             pg_->LoadVar(node_->AsIdentifier(), res_);
+             break;
+@@ -60,9 +60,9 @@ void LReference::GetValue()
+ 
+ void LReference::SetValue()
+ {
+-    switch (refKind_) {
++    switch (ref_kind_) {
+         case ReferenceKind::VAR_OR_GLOBAL: {
+-            pg_->StoreVar(node_, res_, isDeclaration_);
++            pg_->StoreVar(node_, res_, is_declaration_);
+             break;
+         }
+         case ReferenceKind::MEMBER: {
+@@ -86,12 +86,12 @@ void LReference::SetValue()
+ 
+ ReferenceKind LReference::Kind() const
+ {
+-    return refKind_;
++    return ref_kind_;
+ }
+ 
+ binder::Variable *LReference::Variable() const
+ {
+-    return res_.variable;
++    return res_.variable_;
+ }
+ 
+ LReference LReference::CreateLRef(PandaGen *pg, const ir::AstNode *node, bool isDeclaration)
+diff --git a/compiler/base/lreference.h b/compiler/base/lreference.h
+index e7edf06..5da628d 100644
+--- a/compiler/base/lreference.h
++++ b/compiler/base/lreference.h
+@@ -56,11 +56,11 @@ public:
+ private:
+     const ir::AstNode *node_;
+     PandaGen *pg_;
+-    ReferenceKind refKind_;
++    ReferenceKind ref_kind_;
+     binder::ScopeFindResult res_;
+     VReg obj_;
+     Operand prop_;
+-    bool isDeclaration_;
++    bool is_declaration_;
+ };
+ 
+ }  // namespace panda::es2panda::compiler
+diff --git a/compiler/core/compileQueue.cpp b/compiler/core/compileQueue.cpp
+index 29460a7..edea06b 100644
+--- a/compiler/core/compileQueue.cpp
++++ b/compiler/core/compileQueue.cpp
+@@ -76,7 +76,7 @@ CompileQueue::~CompileQueue()
+     std::unique_lock<std::mutex> lock(m_);
+     terminate_ = true;
+     lock.unlock();
+-    jobsAvailable_.notify_all();
++    jobs_available_.notify_all();
+ 
+     for (const auto handle_id : threads_) {
+         os::thread::ThreadJoin(handle_id, &retval);
+@@ -85,24 +85,24 @@ CompileQueue::~CompileQueue()
+ 
+ void CompileQueue::Schedule(CompilerContext *context)
+ {
+-    ASSERT(jobsCount_ == 0);
++    ASSERT(jobs_count_ == 0);
+     std::unique_lock<std::mutex> lock(m_);
+     const auto &functions = context->Binder()->Functions();
+     jobs_ = new CompileJob[functions.size()]();
+ 
+     for (auto *function : functions) {
+-        jobs_[jobsCount_++].SetConext(context, function);
++        jobs_[jobs_count_++].SetConext(context, function);
+     }
+ 
+     lock.unlock();
+-    jobsAvailable_.notify_all();
++    jobs_available_.notify_all();
+ }
+ 
+ void CompileQueue::Worker(CompileQueue *queue)
+ {
+     while (true) {
+         std::unique_lock<std::mutex> lock(queue->m_);
+-        queue->jobsAvailable_.wait(lock, [queue]() { return queue->terminate_ || queue->jobsCount_ != 0; });
++        queue->jobs_available_.wait(lock, [queue]() { return queue->terminate_ || queue->jobs_count_ != 0; });
+ 
+         if (queue->terminate_) {
+             return;
+@@ -111,18 +111,18 @@ void CompileQueue::Worker(CompileQueue *queue)
+         lock.unlock();
+ 
+         queue->Consume();
+-        queue->jobsFinished_.notify_one();
++        queue->jobs_finished_.notify_one();
+     }
+ }
+ 
+ void CompileQueue::Consume()
+ {
+     std::unique_lock<std::mutex> lock(m_);
+-    activeWorkers_++;
++    active_workers_++;
+ 
+-    while (jobsCount_ > 0) {
+-        --jobsCount_;
+-        auto &job = jobs_[jobsCount_];
++    while (jobs_count_ > 0) {
++        --jobs_count_;
++        auto &job = jobs_[jobs_count_];
+ 
+         lock.unlock();
+ 
+@@ -137,13 +137,13 @@ void CompileQueue::Consume()
+         lock.lock();
+     }
+ 
+-    activeWorkers_--;
++    active_workers_--;
+ }
+ 
+ void CompileQueue::Wait()
+ {
+     std::unique_lock<std::mutex> lock(m_);
+-    jobsFinished_.wait(lock, [this]() { return activeWorkers_ == 0 && jobsCount_ == 0; });
++    jobs_finished_.wait(lock, [this]() { return active_workers_ == 0 && jobs_count_ == 0; });
+     delete[] jobs_;
+ 
+     if (!errors_.empty()) {
+diff --git a/compiler/core/compileQueue.h b/compiler/core/compileQueue.h
+index 5e22747..0499a66 100644
+--- a/compiler/core/compileQueue.h
++++ b/compiler/core/compileQueue.h
+@@ -79,11 +79,11 @@ private:
+     std::vector<os::thread::native_handle_type> threads_;
+     std::vector<Error> errors_;
+     std::mutex m_;
+-    std::condition_variable jobsAvailable_;
+-    std::condition_variable jobsFinished_;
++    std::condition_variable jobs_available_;
++    std::condition_variable jobs_finished_;
+     CompileJob *jobs_ {};
+-    size_t jobsCount_ {0};
+-    size_t activeWorkers_ {0};
++    size_t jobs_count_ {0};
++    size_t active_workers_ {0};
+     bool terminate_ {false};
+ };
+ 
+diff --git a/compiler/core/compilerContext.cpp b/compiler/core/compilerContext.cpp
+index 6a97c41..35c62d4 100644
+--- a/compiler/core/compilerContext.cpp
++++ b/compiler/core/compilerContext.cpp
+@@ -20,7 +20,7 @@
+ namespace panda::es2panda::compiler {
+ 
+ CompilerContext::CompilerContext(binder::Binder *binder, bool isDebug)
+-    : binder_(binder), emitter_(std::make_unique<class Emitter>(this)), isDebug_(isDebug)
++    : binder_(binder), emitter_(std::make_unique<class Emitter>(this)), is_debug_(isDebug)
+ {
+ }
+ 
+diff --git a/compiler/core/compilerContext.h b/compiler/core/compilerContext.h
+index 517163a..90a97fa 100644
+--- a/compiler/core/compilerContext.h
++++ b/compiler/core/compilerContext.h
+@@ -50,13 +50,13 @@ public:
+ 
+     int32_t LiteralCount() const
+     {
+-        return literalBufferIdx_;
++        return literal_buffer_idx_;
+     }
+ 
+     int32_t NewLiteralIndex()
+     {
+         std::lock_guard lock(m_);
+-        return literalBufferIdx_++;
++        return literal_buffer_idx_++;
+     }
+ 
+     std::mutex &Mutex()
+@@ -66,15 +66,15 @@ public:
+ 
+     bool IsDebug() const
+     {
+-        return isDebug_;
++        return is_debug_;
+     }
+ 
+ private:
+     binder::Binder *binder_;
+     std::unique_ptr<Emitter> emitter_;
+-    int32_t literalBufferIdx_ {0};
++    int32_t literal_buffer_idx_ {0};
+     std::mutex m_;
+-    bool isDebug_;
++    bool is_debug_;
+ };
+ 
+ }  // namespace panda::es2panda::compiler
+diff --git a/compiler/core/compilerImpl.cpp b/compiler/core/compilerImpl.cpp
+index c4ff569..32d5238 100644
+--- a/compiler/core/compilerImpl.cpp
++++ b/compiler/core/compilerImpl.cpp
+@@ -36,7 +36,7 @@ CompilerImpl::~CompilerImpl()
+ 
+ panda::pandasm::Program *CompilerImpl::Compile(parser::Program *program, const es2panda::CompilerOptions &options)
+ {
+-    CompilerContext context(program->Binder(), options.isDebug);
++    CompilerContext context(program->Binder(), options.is_debug_);
+ 
+     if (program->Extension() == ScriptExtension::TS) {
+         ArenaAllocator localAllocator(SpaceType::SPACE_TYPE_COMPILER, nullptr, true);
+@@ -53,7 +53,7 @@ panda::pandasm::Program *CompilerImpl::Compile(parser::Program *program, const e
+     queue_->Consume();
+     queue_->Wait();
+ 
+-    return context.GetEmitter()->Finalize(options.dumpDebugInfo);
++    return context.GetEmitter()->Finalize(options.dump_debug_info_);
+ }
+ 
+ void CompilerImpl::DumpAsm(const panda::pandasm::Program *prog)
+diff --git a/compiler/core/dynamicContext.cpp b/compiler/core/dynamicContext.cpp
+index 73e9e9d..936ff81 100644
+--- a/compiler/core/dynamicContext.cpp
++++ b/compiler/core/dynamicContext.cpp
+@@ -23,18 +23,19 @@
+ #include <ir/statements/labelledStatement.h>
+ 
+ namespace panda::es2panda::compiler {
+-DynamicContext::DynamicContext(PandaGen *pg, LabelTarget target) : pg_(pg), target_(target), prev_(pg_->dynamicContext_)
++DynamicContext::DynamicContext(PandaGen *pg, LabelTarget target)
++    : pg_(pg), target_(target), prev_(pg_->dynamic_context_)
+ {
+-    pg_->dynamicContext_ = this;
++    pg_->dynamic_context_ = this;
+ }
+ 
+ DynamicContext::~DynamicContext()
+ {
+-    pg_->dynamicContext_ = prev_;
++    pg_->dynamic_context_ = prev_;
+ }
+ 
+ LabelContext::LabelContext(PandaGen *pg, const ir::LabelledStatement *labelledStmt)
+-    : DynamicContext(pg, LabelTarget(labelledStmt->Ident()->Name())), labelledStmt_(labelledStmt)
++    : DynamicContext(pg, LabelTarget(labelledStmt->Ident()->Name())), labelled_stmt_(labelledStmt)
+ {
+     if (!labelledStmt->Body()->IsBlockStatement()) {
+         return;
+@@ -50,31 +51,31 @@ LabelContext::~LabelContext()
+         return;
+     }
+ 
+-    pg_->SetLabel(labelledStmt_, label_);
++    pg_->SetLabel(labelled_stmt_, label_);
+ }
+ 
+ LexEnvContext::LexEnvContext(LoopEnvScope *envScope, PandaGen *pg, LabelTarget target)
+-    : DynamicContext(pg, target), envScope_(envScope)
++    : DynamicContext(pg, target), env_scope_(envScope)
+ {
+-    if (!envScope_->HasEnv()) {
++    if (!env_scope_->HasEnv()) {
+         return;
+     }
+ 
+-    catchTable_ = pg_->CreateCatchTable();
+-    const auto &labelSet = catchTable_->LabelSet();
+-    const auto *node = envScope_->Scope()->Node();
++    catch_table_ = pg_->CreateCatchTable();
++    const auto &labelSet = catch_table_->LabelSet();
++    const auto *node = env_scope_->Scope()->Node();
+ 
+     pg_->SetLabel(node, labelSet.TryBegin());
+ }
+ 
+ LexEnvContext::~LexEnvContext()
+ {
+-    if (!envScope_->HasEnv()) {
++    if (!env_scope_->HasEnv()) {
+         return;
+     }
+ 
+-    const auto &labelSet = catchTable_->LabelSet();
+-    const auto *node = envScope_->Scope()->Node();
++    const auto &labelSet = catch_table_->LabelSet();
++    const auto *node = env_scope_->Scope()->Node();
+ 
+     pg_->SetLabel(node, labelSet.TryEnd());
+     pg_->Branch(node, labelSet.CatchEnd());
+@@ -88,30 +89,30 @@ LexEnvContext::~LexEnvContext()
+ 
+ bool LexEnvContext::HasTryCatch() const
+ {
+-    return envScope_->HasEnv();
++    return env_scope_->HasEnv();
+ }
+ 
+ void LexEnvContext::AbortContext([[maybe_unused]] ControlFlowChange cfc,
+                                  [[maybe_unused]] const util::StringView &targetLabel)
+ {
+-    if (cfc == ControlFlowChange::CONTINUE || !envScope_->HasEnv()) {
++    if (cfc == ControlFlowChange::CONTINUE || !env_scope_->HasEnv()) {
+         return;
+     }
+ 
+-    const auto *node = envScope_->Scope()->Node();
++    const auto *node = env_scope_->Scope()->Node();
+     pg_->PopLexEnv(node);
+ }
+ 
+ IteratorContext::IteratorContext(PandaGen *pg, const Iterator &iterator, LabelTarget target)
+-    : DynamicContext(pg, target), iterator_(iterator), catchTable_(pg->CreateCatchTable())
++    : DynamicContext(pg, target), iterator_(iterator), catch_table_(pg->CreateCatchTable())
+ {
+-    const auto &labelSet = catchTable_->LabelSet();
++    const auto &labelSet = catch_table_->LabelSet();
+     pg_->SetLabel(iterator_.Node(), labelSet.TryBegin());
+ }
+ 
+ IteratorContext::~IteratorContext()
+ {
+-    const auto &labelSet = catchTable_->LabelSet();
++    const auto &labelSet = catch_table_->LabelSet();
+     const auto *node = iterator_.Node();
+ 
+     pg_->SetLabel(node, labelSet.TryEnd());
+@@ -134,40 +135,40 @@ void IteratorContext::AbortContext([[maybe_unused]] ControlFlowChange cfc,
+ 
+ void TryContext::InitFinalizer()
+ {
+-    ASSERT(tryStmt_);
++    ASSERT(try_stmt_);
+ 
+-    if (!hasFinalizer_ || !tryStmt_->FinallyBlock()) {
++    if (!has_finalizer_ || !try_stmt_->FinallyBlock()) {
+         return;
+     }
+ 
+-    finalizerRun_ = pg_->AllocReg();
+-    pg_->StoreConst(tryStmt_, finalizerRun_, Constant::JS_UNDEFINED);
++    finalizer_run_ = pg_->AllocReg();
++    pg_->StoreConst(try_stmt_, finalizer_run_, Constant::JS_UNDEFINED);
+ }
+ 
+ void TryContext::InitCatchTable()
+ {
+-    catchTable_ = pg_->CreateCatchTable();
++    catch_table_ = pg_->CreateCatchTable();
+ }
+ 
+ const TryLabelSet &TryContext::LabelSet() const
+ {
+-    return catchTable_->LabelSet();
++    return catch_table_->LabelSet();
+ }
+ 
+ bool TryContext::HasFinalizer() const
+ {
+-    return hasFinalizer_;
++    return has_finalizer_;
+ }
+ 
+ void TryContext::EmitFinalizer()
+ {
+-    if (!hasFinalizer_ || inFinalizer_ || !tryStmt_->FinallyBlock()) {
++    if (!has_finalizer_ || in_finalizer_ || !try_stmt_->FinallyBlock()) {
+         return;
+     }
+ 
+-    inFinalizer_ = true;
+-    tryStmt_->FinallyBlock()->Compile(pg_);
+-    inFinalizer_ = false;
++    in_finalizer_ = true;
++    try_stmt_->FinallyBlock()->Compile(pg_);
++    in_finalizer_ = false;
+ }
+ 
+ void TryContext::AbortContext([[maybe_unused]] ControlFlowChange cfc,
+diff --git a/compiler/core/dynamicContext.h b/compiler/core/dynamicContext.h
+index 2e13faa..cb766aa 100644
+--- a/compiler/core/dynamicContext.h
++++ b/compiler/core/dynamicContext.h
+@@ -97,7 +97,7 @@ public:
+ 
+ private:
+     Label *label_ {};
+-    const ir::LabelledStatement *labelledStmt_ {};
++    const ir::LabelledStatement *labelled_stmt_ {};
+ };
+ 
+ class LexEnvContext : public DynamicContext {
+@@ -117,8 +117,8 @@ public:
+                       [[maybe_unused]] const util::StringView &targetLabel) override;
+ 
+ private:
+-    LoopEnvScope *envScope_;
+-    CatchTable *catchTable_ {};
++    LoopEnvScope *env_scope_;
++    CatchTable *catch_table_ {};
+ };
+ 
+ class IteratorContext : public DynamicContext {
+@@ -148,13 +148,13 @@ public:
+ 
+ private:
+     const Iterator &iterator_;
+-    CatchTable *catchTable_;
++    CatchTable *catch_table_;
+ };
+ 
+ class TryContext : public DynamicContext {
+ public:
+     explicit TryContext(PandaGen *pg, const ir::TryStatement *tryStmt, bool hasFinalizer = true)
+-        : DynamicContext(pg, {}), tryStmt_(tryStmt), hasFinalizer_(hasFinalizer)
++        : DynamicContext(pg, {}), try_stmt_(tryStmt), has_finalizer_(hasFinalizer)
+     {
+         InitCatchTable();
+         InitFinalizer();
+@@ -181,12 +181,12 @@ public:
+ 
+     VReg FinalizerRun() const
+     {
+-        return finalizerRun_;
++        return finalizer_run_;
+     }
+ 
+     CatchTable *GetCatchTable() const
+     {
+-        return catchTable_;
++        return catch_table_;
+     }
+ 
+     const TryLabelSet &LabelSet() const;
+@@ -200,11 +200,11 @@ public:
+ private:
+     void InitCatchTable();
+ 
+-    const ir::TryStatement *tryStmt_ {};
+-    CatchTable *catchTable_ {};
+-    VReg finalizerRun_ {};
+-    bool hasFinalizer_ {};
+-    bool inFinalizer_ {};
++    const ir::TryStatement *try_stmt_ {};
++    CatchTable *catch_table_ {};
++    VReg finalizer_run_ {};
++    bool has_finalizer_ {};
++    bool in_finalizer_ {};
+ };
+ }  // namespace panda::es2panda::compiler
+ 
+diff --git a/compiler/core/emitter.cpp b/compiler/core/emitter.cpp
+index 6e617cb..86826b8 100644
+--- a/compiler/core/emitter.cpp
++++ b/compiler/core/emitter.cpp
+@@ -41,19 +41,19 @@ namespace panda::es2panda::compiler {
+ constexpr const auto LANG_EXT = panda::pandasm::extensions::Language::ECMASCRIPT;
+ 
+ FunctionEmitter::FunctionEmitter(ArenaAllocator *allocator, const PandaGen *pg)
+-    : pg_(pg), literalBuffers_(allocator->Adapter())
++    : pg_(pg), literal_buffers_(allocator->Adapter())
+ {
+     func_ = allocator->New<panda::pandasm::Function>(pg->InternalName().Mutf8(), LANG_EXT);
+ 
+     size_t paramCount = pg->InternalParamCount();
+-    func_->params.reserve(paramCount);
++    func_->params_.reserve(paramCount);
+ 
+     for (uint32_t i = 0; i < paramCount; ++i) {
+-        func_->params.emplace_back(panda::pandasm::Type("any", 0), LANG_EXT);
++        func_->params_.emplace_back(panda::pandasm::Type("any", 0), LANG_EXT);
+     }
+ 
+-    func_->regs_num = pg->TotalRegsNum();
+-    func_->return_type = panda::pandasm::Type("any", 0);
++    func_->regs_num_ = pg->TotalRegsNum();
++    func_->return_type_ = panda::pandasm::Type("any", 0);
+ }
+ 
+ void FunctionEmitter::Generate()
+@@ -73,7 +73,7 @@ const ArenaSet<util::StringView> &FunctionEmitter::Strings() const
+ 
+ void FunctionEmitter::GenBufferLiterals(const LiteralBuffer *buff)
+ {
+-    auto &[idx, array] = literalBuffers_.emplace_back();
++    auto &[idx, array] = literal_buffers_.emplace_back();
+     idx = buff->Index();
+     array.reserve(buff->Literals().size() * 2);
+ 
+@@ -192,7 +192,7 @@ static size_t GetIRNodeWholeLength(const IRNode *node)
+ 
+ static std::string WholeLine(const util::StringView &source, lexer::SourceRange range)
+ {
+-    return source.Substr(range.start.index, range.end.index).EscapeSymbol<util::StringView::Mutf8Encode>();
++    return source.Substr(range.start_.index_, range.end_.index_).EscapeSymbol<util::StringView::Mutf8Encode>();
+ }
+ 
+ void FunctionEmitter::GenInstructionDebugInfo(const IRNode *ins, panda::pandasm::Ins *pandaIns)
+@@ -202,32 +202,32 @@ void FunctionEmitter::GenInstructionDebugInfo(const IRNode *ins, panda::pandasm:
+     ASSERT(astNode != nullptr);
+ 
+     if (astNode == FIRST_NODE_OF_FUNCTION) {
+-        astNode = pg_->Debuginfo().firstStmt;
++        astNode = pg_->Debuginfo().first_stmt_;
+         if (!astNode) {
+             return;
+         }
+     }
+ 
+-    pandaIns->ins_debug.line_number = astNode->Range().start.line + 1;
++    pandaIns->ins_debug_.line_number_ = astNode->Range().start_.line_ + 1;
+ 
+     if (pg_->IsDebug()) {
+         size_t insLen = GetIRNodeWholeLength(ins);
+         if (insLen != 0) {
+-            pandaIns->ins_debug.bound_left = offset_;
+-            pandaIns->ins_debug.bound_right = offset_ + insLen;
++            pandaIns->ins_debug_.bound_left_ = offset_;
++            pandaIns->ins_debug_.bound_right_ = offset_ + insLen;
+         }
+ 
+         offset_ += insLen;
+-        pandaIns->ins_debug.whole_line = WholeLine(SourceCode(), astNode->Range());
++        pandaIns->ins_debug_.whole_line_ = WholeLine(SourceCode(), astNode->Range());
+     }
+ }
+ 
+ void FunctionEmitter::GenFunctionInstructions()
+ {
+-    func_->ins.reserve(pg_->Insns().size());
++    func_->ins_.reserve(pg_->Insns().size());
+ 
+     for (const auto *ins : pg_->Insns()) {
+-        auto &pandaIns = func_->ins.emplace_back();
++        auto &pandaIns = func_->ins_.emplace_back();
+ 
+         ins->Transform(&pandaIns);
+         GenInstructionDebugInfo(ins, &pandaIns);
+@@ -254,21 +254,21 @@ void FunctionEmitter::GenFunctionICSize()
+             panda::pandasm::ScalarValue::Create<panda::pandasm::Value::Type::STRING>(pg_->FunctionName().Mutf8())));
+     funcAnnotationData.AddElement(std::move(funcNameAnnotationElement));
+ 
+-    func_->metadata->AddAnnotations({funcAnnotationData});
++    func_->metadata_->AddAnnotations({funcAnnotationData});
+ }
+ 
+ void FunctionEmitter::GenFunctionCatchTables()
+ {
+-    func_->catch_blocks.reserve(pg_->CatchList().size());
++    func_->catch_blocks_.reserve(pg_->CatchList().size());
+ 
+     for (const auto *catchBlock : pg_->CatchList()) {
+         const auto &labelSet = catchBlock->LabelSet();
+ 
+-        auto &pandaCatchBlock = func_->catch_blocks.emplace_back();
+-        pandaCatchBlock.try_begin_label = labelSet.TryBegin()->Id();
+-        pandaCatchBlock.try_end_label = labelSet.TryEnd()->Id();
+-        pandaCatchBlock.catch_begin_label = labelSet.CatchBegin()->Id();
+-        pandaCatchBlock.catch_end_label = labelSet.CatchEnd()->Id();
++        auto &pandaCatchBlock = func_->catch_blocks_.emplace_back();
++        pandaCatchBlock.try_begin_label_ = labelSet.TryBegin()->Id();
++        pandaCatchBlock.try_end_label_ = labelSet.TryEnd()->Id();
++        pandaCatchBlock.catch_begin_label_ = labelSet.CatchBegin()->Id();
++        pandaCatchBlock.catch_end_label_ = labelSet.CatchEnd()->Id();
+     }
+ }
+ 
+@@ -281,14 +281,14 @@ void FunctionEmitter::GenLiteralBuffers()
+ 
+ void FunctionEmitter::GenSourceFileDebugInfo()
+ {
+-    func_->source_file = std::string {pg_->Binder()->Program()->SourceFile()};
++    func_->source_file_ = std::string {pg_->Binder()->Program()->SourceFile()};
+ 
+     if (!pg_->IsDebug()) {
+         return;
+     }
+ 
+     if (pg_->RootNode()->IsProgram()) {
+-        func_->source_code = SourceCode().EscapeSymbol<util::StringView::Mutf8Encode>();
++        func_->source_code_ = SourceCode().EscapeSymbol<util::StringView::Mutf8Encode>();
+     }
+ }
+ 
+@@ -311,13 +311,13 @@ void FunctionEmitter::GenScopeVariableInfo(const binder::Scope *scope)
+                     continue;
+                 }
+ 
+-                auto &variableDebug = func_->local_variable_debug.emplace_back();
+-                variableDebug.name = name.Mutf8();
+-                variableDebug.signature = "any";
+-                variableDebug.signature_type = "any";
+-                variableDebug.reg = static_cast<int32_t>(variable->AsLocalVariable()->Vreg());
+-                variableDebug.start = start;
+-                variableDebug.length = static_cast<uint32_t>(varsLength);
++                auto &variableDebug = func_->local_variable_debug_.emplace_back();
++                variableDebug.name_ = name.Mutf8();
++                variableDebug.signature_ = "any";
++                variableDebug.signature_type_ = "any";
++                variableDebug.reg_ = static_cast<int32_t>(variable->AsLocalVariable()->Vreg());
++                variableDebug.start_ = start;
++                variableDebug.length_ = static_cast<uint32_t>(varsLength);
+             }
+ 
+             break;
+@@ -333,7 +333,7 @@ void FunctionEmitter::GenVariablesDebugInfo()
+         return;
+     }
+ 
+-    for (const auto *scope : pg_->Debuginfo().variableDebugInfo) {
++    for (const auto *scope : pg_->Debuginfo().variable_debug_info_) {
+         GenScopeVariableInfo(scope);
+     }
+ }
+@@ -343,9 +343,9 @@ void FunctionEmitter::GenVariablesDebugInfo()
+ Emitter::Emitter(const CompilerContext *context)
+ {
+     prog_ = new panda::pandasm::Program();
+-    prog_->lang = panda::pandasm::extensions::Language::ECMASCRIPT;
++    prog_->lang_ = panda::pandasm::extensions::Language::ECMASCRIPT;
+ 
+-    prog_->function_table.reserve(context->Binder()->Functions().size());
++    prog_->function_table_.reserve(context->Binder()->Functions().size());
+     GenESAnnoatationRecord();
+     GenESModuleModeRecord(context->Binder()->Program()->Kind() == parser::ScriptKind::MODULE);
+ }
+@@ -358,25 +358,25 @@ Emitter::~Emitter()
+ void Emitter::GenESAnnoatationRecord()
+ {
+     auto annotationRecord = panda::pandasm::Record("_ESAnnotation", LANG_EXT);
+-    annotationRecord.metadata->SetAttribute("external");
+-    annotationRecord.metadata->SetAccessFlags(panda::ACC_ANNOTATION);
+-    prog_->record_table.emplace(annotationRecord.name, std::move(annotationRecord));
++    annotationRecord.metadata_->SetAttribute("external");
++    annotationRecord.metadata_->SetAccessFlags(panda::ACC_ANNOTATION);
++    prog_->record_table_.emplace(annotationRecord.name_, std::move(annotationRecord));
+ }
+ 
+ void Emitter::GenESModuleModeRecord(bool isModule)
+ {
+     auto modeRecord = panda::pandasm::Record("_ESModuleMode", LANG_EXT);
+-    modeRecord.metadata->SetAccessFlags(panda::ACC_PUBLIC);
++    modeRecord.metadata_->SetAccessFlags(panda::ACC_PUBLIC);
+ 
+     auto modeField = panda::pandasm::Field(LANG_EXT);
+-    modeField.name = "isModule";
+-    modeField.type = panda::pandasm::Type("u8", 0);
+-    modeField.metadata->SetValue(
++    modeField.name_ = "isModule";
++    modeField.type_ = panda::pandasm::Type("u8", 0);
++    modeField.metadata_->SetValue(
+         panda::pandasm::ScalarValue::Create<panda::pandasm::Value::Type::U8>(static_cast<uint8_t>(isModule)));
+ 
+-    modeRecord.field_list.emplace_back(std::move(modeField));
++    modeRecord.field_list_.emplace_back(std::move(modeField));
+ 
+-    prog_->record_table.emplace(modeRecord.name, std::move(modeRecord));
++    prog_->record_table_.emplace(modeRecord.name_, std::move(modeRecord));
+ }
+ 
+ void Emitter::AddFunction(FunctionEmitter *func)
+@@ -384,16 +384,16 @@ void Emitter::AddFunction(FunctionEmitter *func)
+     std::lock_guard<std::mutex> lock(m_);
+ 
+     for (const auto &str : func->Strings()) {
+-        prog_->strings.insert(str.Mutf8());
++        prog_->strings_.insert(str.Mutf8());
+     }
+ 
+     for (auto &[idx, buf] : func->LiteralBuffers()) {
+         auto literalArrayInstance = panda::pandasm::LiteralArray(std::move(buf));
+-        prog_->literalarray_table.emplace(std::to_string(idx), std::move(literalArrayInstance));
++        prog_->literalarray_table_.emplace(std::to_string(idx), std::move(literalArrayInstance));
+     }
+ 
+     auto *function = func->Function();
+-    prog_->function_table.emplace(function->name, std::move(*function));
++    prog_->function_table_.emplace(function->name_, std::move(*function));
+ }
+ 
+ void Emitter::DumpAsm(const panda::pandasm::Program *prog)
+@@ -402,7 +402,7 @@ void Emitter::DumpAsm(const panda::pandasm::Program *prog)
+ 
+     ss << ".language ECMAScript" << std::endl << std::endl;
+ 
+-    for (auto &[name, func] : prog->function_table) {
++    for (auto &[name, func] : prog->function_table_) {
+         ss << ".function any " << name << '(';
+ 
+         for (uint32_t i = 0; i < func.GetParamsNum(); i++) {
+@@ -415,14 +415,14 @@ void Emitter::DumpAsm(const panda::pandasm::Program *prog)
+ 
+         ss << ") {" << std::endl;
+ 
+-        for (const auto &ins : func.ins) {
+-            ss << (ins.set_label ? "" : "\t") << ins.ToString("", true, func.GetTotalRegs()) << std::endl;
++        for (const auto &ins : func.ins_) {
++            ss << (ins.set_label_ ? "" : "\t") << ins.ToString("", true, func.GetTotalRegs()) << std::endl;
+         }
+ 
+         ss << "}" << std::endl << std::endl;
+ 
+-        for (const auto &ct : func.catch_blocks) {
+-            ss << ".catchall " << ct.try_begin_label << ", " << ct.try_end_label << ", " << ct.catch_begin_label
++        for (const auto &ct : func.catch_blocks_) {
++            ss << ".catchall " << ct.try_begin_label_ << ", " << ct.try_end_label_ << ", " << ct.catch_begin_label_
+                << std::endl
+                << std::endl;
+         }
+diff --git a/compiler/core/emitter.h b/compiler/core/emitter.h
+index addf4b1..176601b 100644
+--- a/compiler/core/emitter.h
++++ b/compiler/core/emitter.h
+@@ -66,7 +66,7 @@ public:
+ 
+     auto &LiteralBuffers()
+     {
+-        return literalBuffers_;
++        return literal_buffers_;
+     }
+ 
+     void Generate();
+@@ -87,7 +87,7 @@ private:
+ 
+     const PandaGen *pg_;
+     panda::pandasm::Function *func_ {};
+-    ArenaVector<std::pair<int32_t, std::vector<panda::pandasm::LiteralArray::Literal>>> literalBuffers_;
++    ArenaVector<std::pair<int32_t, std::vector<panda::pandasm::LiteralArray::Literal>>> literal_buffers_;
+     size_t offset_ {0};
+ };
+ 
+diff --git a/compiler/core/envScope.cpp b/compiler/core/envScope.cpp
+index 6e2fa13..5d5c643 100644
+--- a/compiler/core/envScope.cpp
++++ b/compiler/core/envScope.cpp
+@@ -20,22 +20,22 @@
+ 
+ namespace panda::es2panda::compiler {
+ 
+-ScopeContext::ScopeContext(PandaGen *pg, binder::Scope *newScope) : pg_(pg), prevScope_(pg_->scope_)
++ScopeContext::ScopeContext(PandaGen *pg, binder::Scope *newScope) : pg_(pg), prev_scope_(pg_->scope_)
+ {
+     pg_->scope_ = newScope;
+ }
+ 
+ ScopeContext::~ScopeContext()
+ {
+-    pg_->scope_ = prevScope_;
++    pg_->scope_ = prev_scope_;
+ }
+ 
+ void EnvScope::Initialize(PandaGen *pg, VReg lexEnv)
+ {
+     pg_ = pg;
+-    prev_ = pg_->envScope_;
+-    lexEnv_ = lexEnv;
+-    pg_->envScope_ = this;
++    prev_ = pg_->env_scope_;
++    lex_env_ = lexEnv;
++    pg_->env_scope_ = this;
+ }
+ 
+ EnvScope::~EnvScope()
+@@ -44,7 +44,7 @@ EnvScope::~EnvScope()
+         return;
+     }
+ 
+-    pg_->envScope_ = prev_;
++    pg_->env_scope_ = prev_;
+ }
+ 
+ void LoopEnvScope::CopyBindings(PandaGen *pg, binder::VariableScope *scope, binder::VariableFlags flag)
+@@ -56,7 +56,7 @@ void LoopEnvScope::CopyBindings(PandaGen *pg, binder::VariableScope *scope, bind
+     Initialize(pg, pg->AllocReg());
+ 
+     pg_->NewLexEnv(scope_->Node(), scope->LexicalSlots());
+-    pg_->StoreAccumulator(scope_->Node(), lexEnv_);
++    pg_->StoreAccumulator(scope_->Node(), lex_env_);
+ 
+     ASSERT(scope->NeedLexEnv());
+ 
+@@ -78,7 +78,7 @@ void LoopEnvScope::CopyPetIterationCtx()
+     }
+ 
+     pg_->CopyLexEnv(scope_->Node());
+-    pg_->StoreAccumulator(scope_->Node(), lexEnv_);
++    pg_->StoreAccumulator(scope_->Node(), lex_env_);
+ }
+ 
+ }  // namespace panda::es2panda::compiler
+diff --git a/compiler/core/envScope.h b/compiler/core/envScope.h
+index 55b801a..0d9bdcb 100644
+--- a/compiler/core/envScope.h
++++ b/compiler/core/envScope.h
+@@ -41,7 +41,7 @@ public:
+ 
+ private:
+     PandaGen *pg_;
+-    binder::Scope *prevScope_;
++    binder::Scope *prev_scope_;
+ };
+ 
+ class EnvScope {
+@@ -56,7 +56,7 @@ public:
+ 
+     VReg LexEnv() const
+     {
+-        return lexEnv_;
++        return lex_env_;
+     }
+ 
+     EnvScope *Prev() const
+@@ -69,25 +69,25 @@ protected:
+ 
+     PandaGen *pg_ {};
+     EnvScope *prev_ {};
+-    VReg lexEnv_ {};
++    VReg lex_env_ {};
+ };
+ 
+ class LoopEnvScope : public EnvScope {
+ public:
+     explicit LoopEnvScope(PandaGen *pg, binder::LoopScope *scope, LabelTarget target)
+-        : scope_(NeedEnv(scope) ? scope : nullptr), regScope_(pg, scope), lexEnvCtx_(this, pg, target)
++        : scope_(NeedEnv(scope) ? scope : nullptr), reg_scope_(pg, scope), lex_env_ctx_(this, pg, target)
+     {
+         CopyBindings(pg, scope, binder::VariableFlags::PER_ITERATION);
+     }
+ 
+     explicit LoopEnvScope(PandaGen *pg, LabelTarget target, binder::LoopScope *scope)
+-        : scope_(NeedEnv(scope) ? scope : nullptr), regScope_(pg), lexEnvCtx_(this, pg, target)
++        : scope_(NeedEnv(scope) ? scope : nullptr), reg_scope_(pg), lex_env_ctx_(this, pg, target)
+     {
+         CopyBindings(pg, scope, binder::VariableFlags::PER_ITERATION);
+     }
+ 
+     explicit LoopEnvScope(PandaGen *pg, binder::LoopDeclarationScope *scope)
+-        : scope_(NeedEnv(scope) ? scope : nullptr), regScope_(pg), lexEnvCtx_(this, pg, {})
++        : scope_(NeedEnv(scope) ? scope : nullptr), reg_scope_(pg), lex_env_ctx_(this, pg, {})
+     {
+         CopyBindings(pg, scope, binder::VariableFlags::LOOP_DECL);
+     }
+@@ -114,8 +114,8 @@ private:
+     void CopyBindings(PandaGen *pg, binder::VariableScope *scope, binder::VariableFlags flag);
+ 
+     binder::VariableScope *scope_ {};
+-    LocalRegScope regScope_;
+-    LexEnvContext lexEnvCtx_;
++    LocalRegScope reg_scope_;
++    LexEnvContext lex_env_ctx_;
+ };
+ 
+ }  // namespace panda::es2panda::compiler
+diff --git a/compiler/core/labelTarget.cpp b/compiler/core/labelTarget.cpp
+index 3fc9530..38f386c 100644
+--- a/compiler/core/labelTarget.cpp
++++ b/compiler/core/labelTarget.cpp
+@@ -20,7 +20,7 @@
+ namespace panda::es2panda::compiler {
+ 
+ LabelTarget::LabelTarget(PandaGen *pg)
+-    : LabelPair(pg->AllocLabel(), pg->AllocLabel()), breakLabel_(BREAK_LABEL), continueLabel_(CONTINUE_LABEL)
++    : LabelPair(pg->AllocLabel(), pg->AllocLabel()), break_label_(BREAK_LABEL), continue_label_(CONTINUE_LABEL)
+ {
+ }
+ 
+diff --git a/compiler/core/labelTarget.h b/compiler/core/labelTarget.h
+index 6c9ee97..e8fe4c4 100644
+--- a/compiler/core/labelTarget.h
++++ b/compiler/core/labelTarget.h
+@@ -41,7 +41,7 @@ public:
+     explicit LabelTarget(PandaGen *pg);
+     explicit LabelTarget(const util::StringView &label) : LabelTarget(nullptr, label) {}
+     explicit LabelTarget(Label *target, const util::StringView &label)
+-        : LabelPair(target, nullptr), breakLabel_(label), continueLabel_(label)
++        : LabelPair(target, nullptr), break_label_(label), continue_label_(label)
+     {
+     }
+     LabelTarget() : LabelPair(nullptr, nullptr) {};
+@@ -52,7 +52,7 @@ public:
+ 
+     const util::StringView &BreakLabel() const
+     {
+-        return breakLabel_;
++        return break_label_;
+     }
+ 
+     Label *BreakTarget() const
+@@ -67,7 +67,7 @@ public:
+ 
+     const util::StringView &ContinueLabel() const
+     {
+-        return continueLabel_;
++        return continue_label_;
+     }
+ 
+     Label *ContinueTarget() const
+@@ -79,8 +79,8 @@ public:
+     static constexpr std::string_view CONTINUE_LABEL = "#c";
+ 
+ private:
+-    util::StringView breakLabel_ {};
+-    util::StringView continueLabel_ {};
++    util::StringView break_label_ {};
++    util::StringView continue_label_ {};
+ };
+ 
+ }  // namespace panda::es2panda::compiler
+diff --git a/compiler/core/pandagen.cpp b/compiler/core/pandagen.cpp
+index d4ff04e..c675521 100644
+--- a/compiler/core/pandagen.cpp
++++ b/compiler/core/pandagen.cpp
+@@ -44,7 +44,7 @@ namespace panda::es2panda::compiler {
+ 
+ Label *PandaGen::AllocLabel()
+ {
+-    std::string id = std::string {Label::PREFIX} + std::to_string(labelId_++);
++    std::string id = std::string {Label::PREFIX} + std::to_string(label_id_++);
+     return sa_.AllocLabel(std::move(id));
+ }
+ 
+@@ -55,22 +55,22 @@ bool PandaGen::IsDebug() const
+ 
+ uint32_t PandaGen::ParamCount() const
+ {
+-    if (rootNode_->IsProgram()) {
++    if (root_node_->IsProgram()) {
+         return 0;
+     }
+ 
+-    return rootNode_->AsScriptFunction()->Params().size();
++    return root_node_->AsScriptFunction()->Params().size();
+ }
+ 
+ uint32_t PandaGen::FormalParametersCount() const
+ {
+-    if (rootNode_->IsProgram()) {
++    if (root_node_->IsProgram()) {
+         return 0;
+     }
+ 
+-    ASSERT(rootNode_->IsScriptFunction());
++    ASSERT(root_node_->IsScriptFunction());
+ 
+-    return rootNode_->AsScriptFunction()->FormalParamsLength();
++    return root_node_->AsScriptFunction()->FormalParamsLength();
+ }
+ 
+ uint32_t PandaGen::InternalParamCount() const
+@@ -81,12 +81,12 @@ uint32_t PandaGen::InternalParamCount() const
+ 
+ const util::StringView &PandaGen::InternalName() const
+ {
+-    return topScope_->InternalName();
++    return top_scope_->InternalName();
+ }
+ 
+ const util::StringView &PandaGen::FunctionName() const
+ {
+-    return topScope_->Name();
++    return top_scope_->Name();
+ }
+ 
+ binder::Binder *PandaGen::Binder() const
+@@ -96,12 +96,12 @@ binder::Binder *PandaGen::Binder() const
+ 
+ void PandaGen::FunctionInit(CatchTable *catchTable)
+ {
+-    if (rootNode_->IsProgram()) {
++    if (root_node_->IsProgram()) {
+         builder_ = allocator_->New<FunctionBuilder>(this, catchTable);
+         return;
+     }
+ 
+-    const ir::ScriptFunction *func = rootNode_->AsScriptFunction();
++    const ir::ScriptFunction *func = root_node_->AsScriptFunction();
+ 
+     if (func->IsAsync()) {
+         if (func->IsGenerator()) {
+@@ -123,31 +123,31 @@ void PandaGen::FunctionInit(CatchTable *catchTable)
+ 
+ bool PandaGen::FunctionHasFinalizer() const
+ {
+-    if (rootNode_->IsProgram()) {
++    if (root_node_->IsProgram()) {
+         return false;
+     }
+ 
+-    const ir::ScriptFunction *func = rootNode_->AsScriptFunction();
++    const ir::ScriptFunction *func = root_node_->AsScriptFunction();
+ 
+     return func->IsAsync() || func->IsGenerator();
+ }
+ 
+ void PandaGen::FunctionEnter()
+ {
+-    builder_->Prepare(rootNode_->AsScriptFunction());
++    builder_->Prepare(root_node_->AsScriptFunction());
+ }
+ 
+ void PandaGen::FunctionExit()
+ {
+-    builder_->CleanUp(rootNode_->AsScriptFunction());
++    builder_->CleanUp(root_node_->AsScriptFunction());
+ }
+ 
+ void PandaGen::InitializeLexEnv(const ir::AstNode *node, VReg lexEnv)
+ {
+     FrontAllocator fa(this);
+ 
+-    if (topScope_->NeedLexEnv()) {
+-        NewLexEnv(node, topScope_->LexicalSlots());
++    if (top_scope_->NeedLexEnv()) {
++        NewLexEnv(node, top_scope_->LexicalSlots());
+     } else {
+         LdLexEnv(node);
+     }
+@@ -158,9 +158,9 @@ void PandaGen::InitializeLexEnv(const ir::AstNode *node, VReg lexEnv)
+ void PandaGen::CopyFunctionArguments(const ir::AstNode *node)
+ {
+     FrontAllocator fa(this);
+-    VReg targetReg = totalRegs_;
++    VReg targetReg = total_regs_;
+ 
+-    for (const auto *param : topScope_->ParamScope()->Params()) {
++    for (const auto *param : top_scope_->ParamScope()->Params()) {
+         if (param->LexicalBound()) {
+             LoadAccumulator(node, targetReg++);
+             StoreLexicalVar(node, 0, param->LexIdx());
+@@ -177,7 +177,7 @@ LiteralBuffer *PandaGen::NewLiteralBuffer()
+ 
+ int32_t PandaGen::AddLiteralBuffer(LiteralBuffer *buf)
+ {
+-    buffStorage_.push_back(buf);
++    buff_storage_.push_back(buf);
+     buf->SetIndex(context_->NewLiteralIndex());
+     return buf->Index();
+ }
+@@ -204,10 +204,10 @@ void PandaGen::SetThis(const ir::AstNode *node)
+ 
+ void PandaGen::LoadVar(const ir::Identifier *node, const binder::ScopeFindResult &result)
+ {
+-    auto *var = result.variable;
++    auto *var = result.variable_;
+ 
+     if (!var) {
+-        TryLoadGlobalByName(node, result.name);
++        TryLoadGlobalByName(node, result.name_);
+         return;
+     }
+ 
+@@ -227,10 +227,10 @@ void PandaGen::LoadVar(const ir::Identifier *node, const binder::ScopeFindResult
+ 
+ void PandaGen::StoreVar(const ir::AstNode *node, const binder::ScopeFindResult &result, bool isDeclaration)
+ {
+-    binder::Variable *var = result.variable;
++    binder::Variable *var = result.variable_;
+ 
+     if (!var) {
+-        TryStoreGlobalByName(node, result.name);
++        TryStoreGlobalByName(node, result.name_);
+         return;
+     }
+ 
+@@ -262,7 +262,7 @@ void PandaGen::LoadAccFromArgs(const ir::AstNode *node)
+     }
+ 
+     binder::ScopeFindResult res = scope_->Find(binder::Binder::FUNCTION_ARGUMENTS);
+-    ASSERT(res.scope);
++    ASSERT(res.scope_);
+ 
+     GetUnmappedArgs(node);
+     StoreAccToLexEnv(node, res, true);
+@@ -421,7 +421,7 @@ void PandaGen::StoreGlobalLet(const ir::AstNode *node, const util::StringView &n
+ 
+ VReg PandaGen::LexEnv() const
+ {
+-    return envScope_->LexEnv();
++    return env_scope_->LexEnv();
+ }
+ 
+ void PandaGen::LoadAccFromLexEnv(const ir::AstNode *node, const binder::ScopeFindResult &result)
+@@ -523,7 +523,7 @@ void PandaGen::Branch(const ir::AstNode *node, Label *label)
+ 
+ bool PandaGen::CheckControlFlowChange()
+ {
+-    const auto *iter = dynamicContext_;
++    const auto *iter = dynamic_context_;
+ 
+     while (iter) {
+         if (iter->HasFinalizer()) {
+@@ -538,7 +538,7 @@ bool PandaGen::CheckControlFlowChange()
+ 
+ Label *PandaGen::ControlFlowChangeBreak(const ir::Identifier *label)
+ {
+-    auto *iter = dynamicContext_;
++    auto *iter = dynamic_context_;
+ 
+     util::StringView labelName = label ? label->Name() : LabelTarget::BREAK_LABEL;
+     Label *breakTarget = nullptr;
+@@ -564,7 +564,7 @@ Label *PandaGen::ControlFlowChangeBreak(const ir::Identifier *label)
+ 
+ Label *PandaGen::ControlFlowChangeContinue(const ir::Identifier *label)
+ {
+-    auto *iter = dynamicContext_;
++    auto *iter = dynamic_context_;
+     util::StringView labelName = label ? label->Name() : LabelTarget::CONTINUE_LABEL;
+     Label *continueTarget = nullptr;
+ 
+@@ -1428,7 +1428,7 @@ void PandaGen::LdLexEnv(const ir::AstNode *node)
+ 
+ uint32_t PandaGen::TryDepth() const
+ {
+-    const auto *iter = dynamicContext_;
++    const auto *iter = dynamic_context_;
+     uint32_t depth = 0;
+ 
+     while (iter) {
+@@ -1445,13 +1445,13 @@ uint32_t PandaGen::TryDepth() const
+ CatchTable *PandaGen::CreateCatchTable()
+ {
+     auto *catchTable = allocator_->New<CatchTable>(this, TryDepth());
+-    catchList_.push_back(catchTable);
++    catch_list_.push_back(catchTable);
+     return catchTable;
+ }
+ 
+ void PandaGen::SortCatchTables()
+ {
+-    std::sort(catchList_.begin(), catchList_.end(),
++    std::sort(catch_list_.begin(), catch_list_.end(),
+               [](const CatchTable *a, const CatchTable *b) { return b->Depth() < a->Depth(); });
+ }
+ 
+diff --git a/compiler/core/pandagen.h b/compiler/core/pandagen.h
+index ee623bd..105675e 100644
+--- a/compiler/core/pandagen.h
++++ b/compiler/core/pandagen.h
+@@ -62,13 +62,13 @@ enum class Constant {
+ 
+ class DebugInfo {
+ public:
+-    explicit DebugInfo(ArenaAllocator *allocator) : variableDebugInfo(allocator->Adapter()) {};
++    explicit DebugInfo(ArenaAllocator *allocator) : variable_debug_info_(allocator->Adapter()) {};
+     DEFAULT_COPY_SEMANTIC(DebugInfo);
+     DEFAULT_MOVE_SEMANTIC(DebugInfo);
+     ~DebugInfo() = default;
+ 
+-    ArenaVector<const binder::Scope *> variableDebugInfo;
+-    const ir::Statement *firstStmt {};
++    ArenaVector<const binder::Scope *> variable_debug_info_;
++    const ir::Statement *first_stmt_ {};
+ };
+ 
+ class PandaGen {
+@@ -76,14 +76,14 @@ public:
+     explicit PandaGen(ArenaAllocator *allocator, CompilerContext *context, binder::FunctionScope *scope)
+         : allocator_(allocator),
+           context_(context),
+-          debugInfo_(allocator_),
+-          topScope_(scope),
+-          scope_(topScope_),
+-          rootNode_(scope->Node()),
++          debug_info_(allocator_),
++          top_scope_(scope),
++          scope_(top_scope_),
++          root_node_(scope->Node()),
+           insns_(allocator_->Adapter()),
+-          catchList_(allocator_->Adapter()),
++          catch_list_(allocator_->Adapter()),
+           strings_(allocator_->Adapter()),
+-          buffStorage_(allocator_->Adapter()),
++          buff_storage_(allocator_->Adapter()),
+           sa_(this),
+           ra_(this),
+           rra_(this)
+@@ -105,12 +105,12 @@ public:
+ 
+     const ArenaVector<CatchTable *> &CatchList() const
+     {
+-        return catchList_;
++        return catch_list_;
+     }
+ 
+     binder::FunctionScope *TopScope() const
+     {
+-        return topScope_;
++        return top_scope_;
+     }
+ 
+     binder::Scope *Scope() const
+@@ -120,7 +120,7 @@ public:
+ 
+     const ir::AstNode *RootNode() const
+     {
+-        return rootNode_;
++        return root_node_;
+     }
+ 
+     ArenaList<IRNode *> &Insns()
+@@ -135,27 +135,27 @@ public:
+ 
+     VReg AllocReg()
+     {
+-        return usedRegs_++;
++        return used_regs_++;
+     }
+ 
+     VReg NextReg() const
+     {
+-        return usedRegs_;
++        return used_regs_;
+     }
+ 
+     uint32_t TotalRegsNum() const
+     {
+-        return totalRegs_;
++        return total_regs_;
+     }
+ 
+     size_t LabelCount() const
+     {
+-        return labelId_;
++        return label_id_;
+     }
+ 
+     const DebugInfo &Debuginfo() const
+     {
+-        return debugInfo_;
++        return debug_info_;
+     }
+ 
+     FunctionBuilder *FuncBuilder() const
+@@ -165,12 +165,12 @@ public:
+ 
+     EnvScope *GetEnvScope() const
+     {
+-        return envScope_;
++        return env_scope_;
+     }
+ 
+     const ArenaVector<compiler::LiteralBuffer *> &BuffStorage() const
+     {
+-        return buffStorage_;
++        return buff_storage_;
+     }
+ 
+     uint32_t IcSize() const
+@@ -375,7 +375,7 @@ public:
+ 
+     void SetFirstStmt(const ir::Statement *stmt)
+     {
+-        debugInfo_.firstStmt = stmt;
++        debug_info_.first_stmt_ = stmt;
+     }
+ 
+     [[noreturn]] static void Unimplemented()
+@@ -387,23 +387,23 @@ private:
+     ArenaAllocator *allocator_;
+     CompilerContext *context_;
+     FunctionBuilder *builder_ {nullptr};
+-    DebugInfo debugInfo_;
+-    binder::FunctionScope *topScope_;
++    DebugInfo debug_info_;
++    binder::FunctionScope *top_scope_;
+     binder::Scope *scope_;
+-    const ir::AstNode *rootNode_;
++    const ir::AstNode *root_node_;
+     ArenaList<IRNode *> insns_;
+-    ArenaVector<CatchTable *> catchList_;
++    ArenaVector<CatchTable *> catch_list_;
+     ArenaSet<util::StringView> strings_;
+-    ArenaVector<LiteralBuffer *> buffStorage_;
+-    EnvScope *envScope_ {};
+-    DynamicContext *dynamicContext_ {};
++    ArenaVector<LiteralBuffer *> buff_storage_;
++    EnvScope *env_scope_ {};
++    DynamicContext *dynamic_context_ {};
+     InlineCache ic_;
+     SimpleAllocator sa_;
+     RegAllocator ra_;
+     RangeRegAllocator rra_;
+ 
+-    uint32_t usedRegs_ {0};
+-    uint32_t totalRegs_ {0};
++    uint32_t used_regs_ {0};
++    uint32_t total_regs_ {0};
+     friend class ScopeContext;
+     friend class RegScope;
+     friend class LocalRegScope;
+@@ -413,7 +413,7 @@ private:
+     friend class EnvScope;
+     friend class LoopEnvScope;
+     friend class DynamicContext;
+-    size_t labelId_ {0};
++    size_t label_id_ {0};
+ };
+ }  // namespace panda::es2panda::compiler
+ 
+diff --git a/compiler/core/regAllocator.cpp b/compiler/core/regAllocator.cpp
+index 7ed5763..c6b90e1 100644
+--- a/compiler/core/regAllocator.cpp
++++ b/compiler/core/regAllocator.cpp
+@@ -58,7 +58,7 @@ FrontAllocator::~FrontAllocator()
+ VReg RegAllocatorBase::Spill(IRNode *ins, VReg reg)
+ {
+     VReg spillReg = pg_->AllocReg();
+-    VReg origin = spillIndex_++;
++    VReg origin = spill_index_++;
+ 
+     Add<MovDyn>(ins->Node(), spillReg, origin);
+     Add<MovDyn>(ins->Node(), origin, reg);
+@@ -68,9 +68,9 @@ VReg RegAllocatorBase::Spill(IRNode *ins, VReg reg)
+ 
+ void RegAllocatorBase::Restore(IRNode *ins)
+ {
+-    spillIndex_--;
+-    VReg spillReg = spillIndex_;
+-    VReg origin = regEnd_ + spillIndex_;
++    spill_index_--;
++    VReg spillReg = spill_index_;
++    VReg origin = reg_end_ + spill_index_;
+ 
+     Add<MovDyn>(ins->Node(), origin, spillReg);
+ }
+@@ -79,7 +79,7 @@ void RegAllocatorBase::Restore(IRNode *ins)
+ 
+ void RegAllocator::Run(IRNode *ins)
+ {
+-    ASSERT(spillIndex_ == 0);
++    ASSERT(spill_index_ == 0);
+     std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
+     auto regCnt = ins->Registers(&regs);
+     auto registers = Span<VReg *>(regs.data(), regs.data() + regCnt);
+@@ -91,7 +91,7 @@ void RegAllocator::Run(IRNode *ins)
+ 
+     RegScope regScope(pg_);
+ 
+-    regEnd_ = pg_->NextReg();
++    reg_end_ = pg_->NextReg();
+ 
+     for (auto *reg : registers) {
+         if (IsRegisterCorrect(reg)) {
+@@ -104,7 +104,7 @@ void RegAllocator::Run(IRNode *ins)
+ 
+     PushBack(ins);
+ 
+-    while (spillIndex_ != 0) {
++    while (spill_index_ != 0) {
+         Restore(ins);
+     }
+ }
+@@ -113,7 +113,7 @@ void RegAllocator::Run(IRNode *ins)
+ 
+ void RangeRegAllocator::Run(IRNode *ins, VReg rangeStart, size_t argCount)
+ {
+-    ASSERT(spillIndex_ == 0);
++    ASSERT(spill_index_ == 0);
+     const auto rangeEnd = rangeStart + argCount;
+ 
+     std::array<VReg *, IRNode::MAX_REG_OPERAND> regs {};
+@@ -127,7 +127,7 @@ void RangeRegAllocator::Run(IRNode *ins, VReg rangeStart, size_t argCount)
+ 
+     RegScope regScope(pg_);
+ 
+-    regEnd_ = pg_->NextReg();
++    reg_end_ = pg_->NextReg();
+ 
+     auto *iter = registers.begin();
+     auto *iterEnd = iter + registers.size() - 1;
+@@ -151,7 +151,7 @@ void RangeRegAllocator::Run(IRNode *ins, VReg rangeStart, size_t argCount)
+ 
+     PushBack(ins);
+ 
+-    while (spillIndex_ != 0) {
++    while (spill_index_ != 0) {
+         Restore(ins);
+     }
+ }
+diff --git a/compiler/core/regAllocator.h b/compiler/core/regAllocator.h
+index da5eeff..e187ab2 100644
+--- a/compiler/core/regAllocator.h
++++ b/compiler/core/regAllocator.h
+@@ -121,8 +121,8 @@ protected:
+     VReg Spill(IRNode *ins, VReg reg);
+     void Restore(IRNode *ins);
+ 
+-    VReg spillIndex_ {0};
+-    VReg regEnd_ {0};
++    VReg spill_index_ {0};
++    VReg reg_end_ {0};
+     size_t limit_ {0};
+ };
+ 
+diff --git a/compiler/core/regScope.cpp b/compiler/core/regScope.cpp
+index 588340e..44f006c 100644
+--- a/compiler/core/regScope.cpp
++++ b/compiler/core/regScope.cpp
+@@ -27,12 +27,12 @@ namespace panda::es2panda::compiler {
+ 
+ // RegScope
+ 
+-RegScope::RegScope(PandaGen *pg) : pg_(pg), regBase_(pg_->usedRegs_) {}
++RegScope::RegScope(PandaGen *pg) : pg_(pg), reg_base_(pg_->used_regs_) {}
+ 
+ RegScope::~RegScope()
+ {
+-    pg_->totalRegs_ = std::max(pg_->totalRegs_, pg_->usedRegs_);
+-    pg_->usedRegs_ = regBase_;
++    pg_->total_regs_ = std::max(pg_->total_regs_, pg_->used_regs_);
++    pg_->used_regs_ = reg_base_;
+ }
+ 
+ void RegScope::DebuggerCloseScope()
+@@ -50,7 +50,7 @@ LocalRegScope::LocalRegScope(PandaGen *pg) : RegScope(pg) {}
+ 
+ LocalRegScope::LocalRegScope(PandaGen *pg, binder::Scope *scope) : RegScope(pg)
+ {
+-    prevScope_ = pg_->scope_;
++    prev_scope_ = pg_->scope_;
+     pg_->scope_ = scope;
+ 
+     for (const auto &[_, var] : scope->Bindings()) {
+@@ -62,7 +62,7 @@ LocalRegScope::LocalRegScope(PandaGen *pg, binder::Scope *scope) : RegScope(pg)
+ 
+     if (pg_->IsDebug()) {
+         pg_->scope_->SetScopeStart(pg_->insns_.back());
+-        pg_->debugInfo_.variableDebugInfo.push_back(pg_->scope_);
++        pg_->debug_info_.variable_debug_info_.push_back(pg_->scope_);
+     }
+ 
+     Hoisting::Hoist(pg_);
+@@ -70,18 +70,18 @@ LocalRegScope::LocalRegScope(PandaGen *pg, binder::Scope *scope) : RegScope(pg)
+ 
+ LocalRegScope::~LocalRegScope()
+ {
+-    if (!prevScope_) {
++    if (!prev_scope_) {
+         return;
+     }
+ 
+     DebuggerCloseScope();
+ 
+-    pg_->scope_ = prevScope_;
++    pg_->scope_ = prev_scope_;
+ }
+ 
+ // FunctionRegScope
+ 
+-FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), envScope_(pg->Allocator()->New<EnvScope>())
++FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), env_scope_(pg->Allocator()->New<EnvScope>())
+ {
+     ASSERT(pg_->Scope()->IsFunctionVariableScope());
+     ASSERT(pg_->NextReg() == binder::Binder::MANDATORY_PARAM_FUNC_REG);
+@@ -95,7 +95,7 @@ FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), envScope_(pg->A
+         }
+     }
+ 
+-    envScope_->Initialize(pg_, pg->AllocReg());
++    env_scope_->Initialize(pg_, pg->AllocReg());
+ 
+     for (const auto &[_, var] : funcScope->Bindings()) {
+         (void)_;
+@@ -109,10 +109,10 @@ FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), envScope_(pg->A
+     }
+ 
+     if (pg_->IsDebug()) {
+-        pg_->debugInfo_.variableDebugInfo.push_back(funcScope);
++        pg_->debug_info_.variable_debug_info_.push_back(funcScope);
+     }
+ 
+-    pg_->LoadAccFromArgs(pg_->rootNode_);
++    pg_->LoadAccFromArgs(pg_->root_node_);
+ 
+     if (funcScope->IsModuleScope()) {
+         ModuleContext::Compile(pg_, pg_->scope_->AsModuleScope());
+@@ -124,12 +124,12 @@ FunctionRegScope::FunctionRegScope(PandaGen *pg) : RegScope(pg), envScope_(pg->A
+ FunctionRegScope::~FunctionRegScope()
+ {
+     if (pg_->IsDebug()) {
+-        pg_->topScope_->SetScopeStart(pg_->insns_.front());
++        pg_->top_scope_->SetScopeStart(pg_->insns_.front());
+     }
+ 
+     DebuggerCloseScope();
+ 
+-    envScope_->~EnvScope();
++    env_scope_->~EnvScope();
+ }
+ 
+ }  // namespace panda::es2panda::compiler
+diff --git a/compiler/core/regScope.h b/compiler/core/regScope.h
+index a34029c..b0b71a6 100644
+--- a/compiler/core/regScope.h
++++ b/compiler/core/regScope.h
+@@ -42,7 +42,7 @@ protected:
+     void DebuggerCloseScope();
+ 
+     PandaGen *pg_;
+-    uint32_t regBase_;
++    uint32_t reg_base_;
+ };
+ 
+ class LocalRegScope : public RegScope {
+@@ -57,7 +57,7 @@ public:
+     void *operator new[](size_t) = delete;
+ 
+ private:
+-    binder::Scope *prevScope_ {};
++    binder::Scope *prev_scope_ {};
+ };
+ 
+ class LoopRegScope : public RegScope {
+@@ -71,7 +71,7 @@ public:
+     void *operator new[](size_t) = delete;
+ 
+ private:
+-    binder::Scope *prevScope_ {};
++    binder::Scope *prev_scope_ {};
+ };
+ 
+ class FunctionRegScope : public RegScope {
+@@ -85,7 +85,7 @@ public:
+     void *operator new[](size_t) = delete;
+ 
+ private:
+-    EnvScope *envScope_;
++    EnvScope *env_scope_;
+ };
+ 
+ }  // namespace panda::es2panda::compiler
+diff --git a/compiler/core/switchBuilder.cpp b/compiler/core/switchBuilder.cpp
+index 6dfa51d..d17bfb7 100644
+--- a/compiler/core/switchBuilder.cpp
++++ b/compiler/core/switchBuilder.cpp
+@@ -26,10 +26,10 @@ namespace panda::es2panda::compiler {
+ // SwitchBuilder
+ 
+ SwitchBuilder::SwitchBuilder(PandaGen *pg, const ir::SwitchStatement *stmt)
+-    : pg_(pg), end_(pg->AllocLabel()), labelCtx_(pg, LabelTarget(end_, LabelTarget::BREAK_LABEL)), stmt_(stmt)
++    : pg_(pg), end_(pg->AllocLabel()), label_ctx_(pg, LabelTarget(end_, LabelTarget::BREAK_LABEL)), stmt_(stmt)
+ {
+     for (size_t i = 0; i < stmt_->Cases().size(); i++) {
+-        caseLabels_.push_back(pg_->AllocLabel());
++        case_labels_.push_back(pg_->AllocLabel());
+     }
+ }
+ 
+@@ -40,7 +40,7 @@ SwitchBuilder::~SwitchBuilder()
+ 
+ void SwitchBuilder::SetCaseTarget(uint32_t index)
+ {
+-    pg_->SetLabel(stmt_->Cases()[index], caseLabels_[index]);
++    pg_->SetLabel(stmt_->Cases()[index], case_labels_[index]);
+ }
+ 
+ void SwitchBuilder::CompileTagOfSwitch(VReg tag)
+@@ -60,13 +60,13 @@ void SwitchBuilder::JumpIfCase(VReg tag, uint32_t index)
+ {
+     const ir::SwitchCaseStatement *caseTarget = stmt_->Cases()[index];
+     caseTarget->Test()->Compile(pg_);
+-    pg_->Condition(caseTarget, lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL, tag, caseLabels_[index]);
++    pg_->Condition(caseTarget, lexer::TokenType::PUNCTUATOR_NOT_STRICT_EQUAL, tag, case_labels_[index]);
+ }
+ 
+ void SwitchBuilder::JumpToDefault(uint32_t defaultIndex)
+ {
+     const ir::SwitchCaseStatement *defaultTarget = stmt_->Cases()[defaultIndex];
+-    pg_->Branch(defaultTarget, caseLabels_[defaultIndex]);
++    pg_->Branch(defaultTarget, case_labels_[defaultIndex]);
+ }
+ 
+ void SwitchBuilder::Break()
+diff --git a/compiler/core/switchBuilder.h b/compiler/core/switchBuilder.h
+index cea6db1..ad7f6bc 100644
+--- a/compiler/core/switchBuilder.h
++++ b/compiler/core/switchBuilder.h
+@@ -44,9 +44,9 @@ public:
+ private:
+     PandaGen *pg_;
+     Label *end_;
+-    LabelContext labelCtx_;
++    LabelContext label_ctx_;
+     const ir::SwitchStatement *stmt_;
+-    std::vector<Label *> caseLabels_;
++    std::vector<Label *> case_labels_;
+ };
+ }  // namespace panda::es2panda::compiler
+ 
+diff --git a/compiler/debugger/debuginfoDumper.cpp b/compiler/debugger/debuginfoDumper.cpp
+index 24f9745..f3ecbfa 100644
+--- a/compiler/debugger/debuginfoDumper.cpp
++++ b/compiler/debugger/debuginfoDumper.cpp
+@@ -64,7 +64,7 @@ void DebugInfoDumper::WrapArray(const char *name, const std::vector<T> &array, b
+                 WriteIns(*elem);
+                 // NOLINTNEXTLINE
+             } else if constexpr (std::is_same_v<T, pandasm::Function::Parameter>) {
+-                ss_ << "\"" << (*elem).type.GetName() << "\"";
++                ss_ << "\"" << (*elem).type_.GetName() << "\"";
+                 // NOLINTNEXTLINE
+             } else if constexpr (std::is_same_v<T, std::string>) {
+                 ss_ << "\"" << *elem << "\"";
+@@ -96,20 +96,20 @@ void DebugInfoDumper::WriteIns(const pandasm::Ins &ins)
+     ss_ << "{";
+     {
+         pandasm::Ins insCopy;
+-        insCopy.opcode = ins.opcode;
+-        insCopy.set_label = ins.set_label;
+-        insCopy.label = ins.label;
++        insCopy.opcode_ = ins.opcode_;
++        insCopy.set_label_ = ins.set_label_;
++        insCopy.label_ = ins.label_;
+         WriteProperty("opcode", insCopy.ToString());
+     }
+     indent_++;
+-    WrapArray("regs", ins.regs);
+-    WrapArray("ids", ins.ids);
+-    WrapArray("imms", ins.imms);
++    WrapArray("regs", ins.regs_);
++    WrapArray("ids", ins.ids_);
++    WrapArray("imms", ins.imms_);
+     ss_ << std::endl;
+     Indent();
+     ss_ << "\"label\": "
+-        << "\"" << ins.label << "\",";
+-    WritePosInfo(ins.ins_debug);
++        << "\"" << ins.label_ << "\",";
++    WritePosInfo(ins.ins_debug_);
+     indent_--;
+     Indent();
+     ss_ << "}";
+@@ -134,10 +134,10 @@ void DebugInfoDumper::WritePosInfo(const pandasm::debuginfo::Ins &posInfo)
+     ss_ << std::endl;
+     Indent();
+     ss_ << "\"debug_pos_info\": {";
+-    WriteProperty("boundLeft", posInfo.bound_left);
+-    WriteProperty("boundRight", posInfo.bound_right);
+-    WriteProperty("sourecLineNum", static_cast<int32_t>(posInfo.line_number));
+-    WriteProperty("wholeLine", posInfo.whole_line, false);
++    WriteProperty("boundLeft", posInfo.bound_left_);
++    WriteProperty("boundRight", posInfo.bound_right_);
++    WriteProperty("sourecLineNum", static_cast<int32_t>(posInfo.line_number_));
++    WriteProperty("wholeLine", posInfo.whole_line_, false);
+     Indent();
+     ss_ << "}" << std::endl;
+ }
+@@ -145,12 +145,12 @@ void DebugInfoDumper::WritePosInfo(const pandasm::debuginfo::Ins &posInfo)
+ void DebugInfoDumper::WriteVariableInfo(const pandasm::debuginfo::LocalVariable &localVariableDebug)
+ {
+     ss_ << "{";
+-    WriteProperty("name", localVariableDebug.name);
+-    WriteProperty("signature", localVariableDebug.signature);
+-    WriteProperty("signatureType", localVariableDebug.signature_type);
+-    WriteProperty("reg", localVariableDebug.reg);
+-    WriteProperty("start", static_cast<size_t>(localVariableDebug.start));
+-    WriteProperty("length", static_cast<size_t>(localVariableDebug.length), false);
++    WriteProperty("name", localVariableDebug.name_);
++    WriteProperty("signature", localVariableDebug.signature_);
++    WriteProperty("signatureType", localVariableDebug.signature_type_);
++    WriteProperty("reg", localVariableDebug.reg_);
++    WriteProperty("start", static_cast<size_t>(localVariableDebug.start_));
++    WriteProperty("length", static_cast<size_t>(localVariableDebug.length_), false);
+     Indent();
+     ss_ << "}";
+ }
+@@ -162,9 +162,9 @@ void DebugInfoDumper::Dump()
+     Indent();
+     ss_ << "\"functions\": [" << std::endl;
+ 
+-    auto iter = prog_->function_table.begin();
++    auto iter = prog_->function_table_.begin();
+ 
+-    for (; iter != prog_->function_table.end(); ++iter) {
++    for (; iter != prog_->function_table_.end(); ++iter) {
+         indent_++;
+         Indent();
+         ss_ << "{";
+@@ -174,26 +174,26 @@ void DebugInfoDumper::Dump()
+         indent_++;
+         Indent();
+         ss_ << "\"signature\": {";
+-        WriteProperty("retType", iter->second.return_type.GetName());
++        WriteProperty("retType", iter->second.return_type_.GetName());
+         indent_++;
+-        WrapArray("params", iter->second.params, false);
++        WrapArray("params", iter->second.params_, false);
+         indent_ -= 2U;
+         ss_ << std::endl;
+         Indent();
+         ss_ << "},";
+ 
+-        WrapArray("ins", iter->second.ins);
+-        WrapArray("variables", iter->second.local_variable_debug);
+-        WriteProperty("sourceFile", iter->second.source_file);
+-        WriteProperty("sourceCode", iter->second.source_code);
++        WrapArray("ins", iter->second.ins_);
++        WrapArray("variables", iter->second.local_variable_debug_);
++        WriteProperty("sourceFile", iter->second.source_file_);
++        WriteProperty("sourceCode", iter->second.source_code_);
+         // icSize - parameterLength - funcName
+-        WriteMetaData(iter->second.metadata->GetAnnotations());
++        WriteMetaData(iter->second.metadata_->GetAnnotations());
+ 
+         indent_--;
+         Indent();
+         ss_ << "}";
+ 
+-        if (std::next(iter) != prog_->function_table.end()) {
++        if (std::next(iter) != prog_->function_table_.end()) {
+             ss_ << ",";
+         }
+ 
+diff --git a/compiler/function/asyncFunctionBuilder.cpp b/compiler/function/asyncFunctionBuilder.cpp
+index acbbc79..f097a6a 100644
+--- a/compiler/function/asyncFunctionBuilder.cpp
++++ b/compiler/function/asyncFunctionBuilder.cpp
+@@ -23,7 +23,7 @@ namespace panda::es2panda::compiler {
+ 
+ void AsyncFunctionBuilder::DirectReturn(const ir::AstNode *node) const
+ {
+-    pg_->AsyncFunctionResolve(node, funcObj_);
++    pg_->AsyncFunctionResolve(node, func_obj_);
+     pg_->EmitReturn(node);
+ }
+ 
+@@ -36,17 +36,17 @@ void AsyncFunctionBuilder::ImplicitReturn(const ir::AstNode *node) const
+ void AsyncFunctionBuilder::Prepare(const ir::ScriptFunction *node) const
+ {
+     pg_->AsyncFunctionEnter(node);
+-    pg_->StoreAccumulator(node, funcObj_);
+-    pg_->SetLabel(node, catchTable_->LabelSet().TryBegin());
++    pg_->StoreAccumulator(node, func_obj_);
++    pg_->SetLabel(node, catch_table_->LabelSet().TryBegin());
+ }
+ 
+ void AsyncFunctionBuilder::CleanUp(const ir::ScriptFunction *node) const
+ {
+-    const auto &labelSet = catchTable_->LabelSet();
++    const auto &labelSet = catch_table_->LabelSet();
+ 
+     pg_->SetLabel(node, labelSet.TryEnd());
+     pg_->SetLabel(node, labelSet.CatchBegin());
+-    pg_->AsyncFunctionReject(node, funcObj_);
++    pg_->AsyncFunctionReject(node, func_obj_);
+     pg_->EmitReturn(node);
+     pg_->SetLabel(node, labelSet.CatchEnd());
+ }
+diff --git a/compiler/function/asyncGeneratorFunctionBuilder.cpp b/compiler/function/asyncGeneratorFunctionBuilder.cpp
+index c4360cd..415c77c 100644
+--- a/compiler/function/asyncGeneratorFunctionBuilder.cpp
++++ b/compiler/function/asyncGeneratorFunctionBuilder.cpp
+@@ -25,25 +25,25 @@ void AsyncGeneratorFunctionBuilder::Prepare(const ir::ScriptFunction *node) cons
+     VReg callee = FunctionReg(node);
+ 
+     pg_->CreateAsyncGeneratorObj(node, callee);
+-    pg_->StoreAccumulator(node, funcObj_);
+-    pg_->SuspendGenerator(node, funcObj_);
+-    pg_->SetLabel(node, catchTable_->LabelSet().TryBegin());
++    pg_->StoreAccumulator(node, func_obj_);
++    pg_->SuspendGenerator(node, func_obj_);
++    pg_->SetLabel(node, catch_table_->LabelSet().TryBegin());
+ }
+ 
+ void AsyncGeneratorFunctionBuilder::CleanUp(const ir::ScriptFunction *node) const
+ {
+-    const auto &labelSet = catchTable_->LabelSet();
++    const auto &labelSet = catch_table_->LabelSet();
+ 
+     pg_->SetLabel(node, labelSet.TryEnd());
+     pg_->SetLabel(node, labelSet.CatchBegin());
+-    pg_->AsyncGeneratorReject(node, funcObj_);
++    pg_->AsyncGeneratorReject(node, func_obj_);
+     pg_->EmitReturn(node);
+     pg_->SetLabel(node, labelSet.CatchEnd());
+ }
+ 
+ void AsyncGeneratorFunctionBuilder::DirectReturn(const ir::AstNode *node) const
+ {
+-    pg_->AsyncGeneratorResolve(node, funcObj_);
++    pg_->AsyncGeneratorResolve(node, func_obj_);
+     pg_->EmitReturn(node);
+ }
+ 
+@@ -72,7 +72,7 @@ void AsyncGeneratorFunctionBuilder::Yield(const ir::AstNode *node)
+     pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, completionType, notReturnCompletion);
+     // 27.6.3.8.8.b. Let awaited be Await(resumptionValue.[[Value]]).
+     pg_->LoadAccumulator(node, completionValue);
+-    pg_->AsyncFunctionAwait(node, funcObj_);
++    pg_->AsyncFunctionAwait(node, func_obj_);
+     SuspendResumeExecution(node, completionType, completionValue);
+ 
+     // 27.6.3.8.8.c. If awaited.[[Type]] is throw, return Completion(awaited).
+diff --git a/compiler/function/functionBuilder.cpp b/compiler/function/functionBuilder.cpp
+index eaba22a..a5fc932 100644
+--- a/compiler/function/functionBuilder.cpp
++++ b/compiler/function/functionBuilder.cpp
+@@ -25,7 +25,7 @@
+ namespace panda::es2panda::compiler {
+ 
+ FunctionBuilder::FunctionBuilder(PandaGen *pg, CatchTable *catchTable)
+-    : pg_(pg), catchTable_(catchTable), funcObj_(pg_->AllocReg())
++    : pg_(pg), catch_table_(catchTable), func_obj_(pg_->AllocReg())
+ {
+ }
+ 
+@@ -57,8 +57,8 @@ void FunctionBuilder::AsyncYield(const ir::AstNode *node, VReg completionType, V
+ {
+     ASSERT(BuilderKind() == BuilderType::ASYNC_GENERATOR);
+ 
+-    pg_->GeneratorYield(node, funcObj_);
+-    pg_->SuspendAsyncGenerator(node, funcObj_);
++    pg_->GeneratorYield(node, func_obj_);
++    pg_->SuspendAsyncGenerator(node, func_obj_);
+ 
+     resumeGenerator(node, completionType, completionValue);
+ }
+@@ -68,7 +68,7 @@ void FunctionBuilder::SuspendResumeExecution(const ir::AstNode *node, VReg compl
+     ASSERT(BuilderKind() == BuilderType::ASYNC || BuilderKind() == BuilderType::ASYNC_GENERATOR ||
+            BuilderKind() == BuilderType::GENERATOR);
+ 
+-    pg_->SuspendGenerator(node, funcObj_);
++    pg_->SuspendGenerator(node, func_obj_);
+     resumeGenerator(node, completionType, completionValue);
+ }
+ 
+@@ -77,9 +77,9 @@ void FunctionBuilder::resumeGenerator(const ir::AstNode *node, VReg completionTy
+     ASSERT(BuilderKind() == BuilderType::ASYNC || BuilderKind() == BuilderType::ASYNC_GENERATOR ||
+            BuilderKind() == BuilderType::GENERATOR);
+ 
+-    pg_->ResumeGenerator(node, funcObj_);
++    pg_->ResumeGenerator(node, func_obj_);
+     pg_->StoreAccumulator(node, completionValue);
+-    pg_->GetResumeMode(node, funcObj_);
++    pg_->GetResumeMode(node, func_obj_);
+     pg_->StoreAccumulator(node, completionType);
+ }
+ 
+@@ -87,8 +87,8 @@ VReg FunctionBuilder::FunctionReg(const ir::ScriptFunction *node) const
+ {
+     binder::FunctionScope *scope = node->Scope();
+     auto res = scope->Find(binder::Binder::MANDATORY_PARAM_FUNC);
+-    ASSERT(res.level == 0 && res.variable->IsLocalVariable());
+-    return res.variable->AsLocalVariable()->Vreg();
++    ASSERT(res.level_ == 0 && res.variable_->IsLocalVariable());
++    return res.variable_->AsLocalVariable()->Vreg();
+ }
+ 
+ void FunctionBuilder::Await(const ir::AstNode *node)
+@@ -104,7 +104,7 @@ void FunctionBuilder::Await(const ir::AstNode *node)
+     VReg completionType = pg_->AllocReg();
+     VReg completionValue = pg_->AllocReg();
+ 
+-    pg_->AsyncFunctionAwait(node, funcObj_);
++    pg_->AsyncFunctionAwait(node, func_obj_);
+     SuspendResumeExecution(node, completionType, completionValue);
+ 
+     HandleCompletion(node, completionType, completionValue);
+@@ -117,10 +117,10 @@ void FunctionBuilder::HandleCompletion(const ir::AstNode *node, VReg completionT
+ 
+     auto *notRetLabel = pg_->AllocLabel();
+     pg_->Condition(node, lexer::TokenType::PUNCTUATOR_EQUAL, completionType, notRetLabel);
+-    if (!handleReturn_) {
+-        handleReturn_ = true;
++    if (!handle_return_) {
++        handle_return_ = true;
+         pg_->ControlFlowChangeBreak();
+-        handleReturn_ = false;
++        handle_return_ = false;
+     }
+ 
+     pg_->LoadAccumulator(node, completionValue);
+@@ -265,7 +265,7 @@ void FunctionBuilder::YieldStar(const ir::AstNode *node)
+ 
+         // b. Let awaited be Await(resumptionValue.[[Value]]).
+         pg_->LoadAccumulator(node, receivedValue);
+-        pg_->AsyncFunctionAwait(node, funcObj_);
++        pg_->AsyncFunctionAwait(node, func_obj_);
+         SuspendResumeExecution(node, receivedType, receivedValue);
+ 
+         // c. If awaited.[[Type]] is throw, return Completion(awaited).
+@@ -277,7 +277,7 @@ void FunctionBuilder::YieldStar(const ir::AstNode *node)
+         // vii. Else, set received to GeneratorYield(innerResult).
+         // 8. Else, set received to GeneratorYield(innerResult).
+         // x. Else, set received to GeneratorYield(innerReturnResult).
+-        pg_->GeneratorYield(node, funcObj_);
++        pg_->GeneratorYield(node, func_obj_);
+         SuspendResumeExecution(node, receivedType, receivedValue);
+     }
+ 
+diff --git a/compiler/function/functionBuilder.h b/compiler/function/functionBuilder.h
+index 4147c49..c957d8b 100644
+--- a/compiler/function/functionBuilder.h
++++ b/compiler/function/functionBuilder.h
+@@ -78,9 +78,9 @@ protected:
+     void HandleCompletion(const ir::AstNode *node, VReg completionType, VReg completionValue);
+ 
+     PandaGen *pg_;
+-    CatchTable *catchTable_;
+-    VReg funcObj_ {};
+-    bool handleReturn_ {};
++    CatchTable *catch_table_;
++    VReg func_obj_ {};
++    bool handle_return_ {};
+ 
+ private:
+     void resumeGenerator(const ir::AstNode *node, VReg completionType, VReg completionValue) const;
+diff --git a/compiler/function/generatorFunctionBuilder.cpp b/compiler/function/generatorFunctionBuilder.cpp
+index a4d71b3..ae7e5ed 100644
+--- a/compiler/function/generatorFunctionBuilder.cpp
++++ b/compiler/function/generatorFunctionBuilder.cpp
+@@ -26,25 +26,25 @@ void GeneratorFunctionBuilder::Prepare(const ir::ScriptFunction *node) const
+     VReg callee = FunctionReg(node);
+ 
+     pg_->CreateGeneratorObj(node, callee);
+-    pg_->StoreAccumulator(node, funcObj_);
+-    pg_->SuspendGenerator(node, funcObj_);
+-    pg_->SetLabel(node, catchTable_->LabelSet().TryBegin());
++    pg_->StoreAccumulator(node, func_obj_);
++    pg_->SuspendGenerator(node, func_obj_);
++    pg_->SetLabel(node, catch_table_->LabelSet().TryBegin());
+ }
+ 
+ void GeneratorFunctionBuilder::CleanUp(const ir::ScriptFunction *node) const
+ {
+-    const auto &labelSet = catchTable_->LabelSet();
++    const auto &labelSet = catch_table_->LabelSet();
+ 
+     pg_->SetLabel(node, labelSet.TryEnd());
+     pg_->SetLabel(node, labelSet.CatchBegin());
+-    pg_->GeneratorComplete(node, funcObj_);
++    pg_->GeneratorComplete(node, func_obj_);
+     pg_->EmitThrow(node);
+     pg_->SetLabel(node, labelSet.CatchEnd());
+ }
+ 
+ void GeneratorFunctionBuilder::DirectReturn(const ir::AstNode *node) const
+ {
+-    pg_->GeneratorComplete(node, funcObj_);
++    pg_->GeneratorComplete(node, func_obj_);
+     pg_->CreateIterResultObject(node, true);
+     pg_->EmitReturn(node);
+ }
+@@ -62,7 +62,7 @@ void GeneratorFunctionBuilder::Yield(const ir::AstNode *node)
+     VReg completionValue = pg_->AllocReg();
+ 
+     pg_->CreateIterResultObject(node, false);
+-    pg_->GeneratorYield(node, funcObj_);
++    pg_->GeneratorYield(node, func_obj_);
+     SuspendResumeExecution(node, completionType, completionValue);
+ 
+     HandleCompletion(node, completionType, completionValue);
+diff --git a/compiler/templates/isa.h.erb b/compiler/templates/isa.h.erb
+index 49a5d58..709243b 100644
+--- a/compiler/templates/isa.h.erb
++++ b/compiler/templates/isa.h.erb
+@@ -59,9 +59,9 @@ public:
+ 
+     void Transform(pandasm::Ins *ins) const override
+     {
+-        ins->opcode = pandasm::Opcode::INVALID;
+-        ins->set_label = true;
+-        ins->label = id_;
++        ins->opcode_ = pandasm::Opcode::INVALID;
++        ins->set_label_ = true;
++        ins->label_ = id_;
+     }
+ 
+ private:
+@@ -196,27 +196,27 @@ public:
+     }
+ 
+     void Transform(pandasm::Ins* ins) const override {
+-      ins->opcode = pandasm::Opcode::<%= node_kind %>;
++      ins->opcode_ = pandasm::Opcode::<%= node_kind %>;
+ % if op_map['reg'].length != 0
+-      ins->regs.reserve(<%= op_map['reg'].length %>);
++      ins->regs_.reserve(<%= op_map['reg'].length %>);
+ % end
+ % if op_map['imm'].length != 0
+-      ins->imms.reserve(<%= op_map['imm'].length %>);
++      ins->imms_.reserve(<%= op_map['imm'].length %>);
+ % end
+ % if op_map['str'].length + op_map['lbl'].length != 0
+-      ins->ids.reserve(<%= op_map['str'].length + op_map['lbl'].length %>);
++      ins->ids_.reserve(<%= op_map['str'].length + op_map['lbl'].length %>);
+ % end
+ % for reg in op_map['reg']
+-      ins->regs.emplace_back(<%= reg %>);
++      ins->regs_.emplace_back(<%= reg %>);
+ % end
+ % for imm in op_map['imm']
+-      ins->imms.emplace_back(<%= imm %>);
++      ins->imms_.emplace_back(<%= imm %>);
+ % end
+ % for str in op_map['str']
+-      ins->ids.emplace_back(<%= str %>.Mutf8());
++      ins->ids_.emplace_back(<%= str %>.Mutf8());
+ % end
+ % for lbl in op_map['lbl']
+-      ins->ids.emplace_back(<%= lbl %>->Id());
++      ins->ids_.emplace_back(<%= lbl %>->Id());
+ % end
+     }
+ 
+diff --git a/es2panda.cpp b/es2panda.cpp
+index 7bb4127..3e3f0cf 100644
+--- a/es2panda.cpp
++++ b/es2panda.cpp
+@@ -45,17 +45,17 @@ Compiler::~Compiler()
+ panda::pandasm::Program *Compiler::Compile(const SourceFile &input, const CompilerOptions &options)
+ {
+     /* TODO(dbatyai): pass string view */
+-    std::string fname(input.fileName);
+-    std::string src(input.source);
++    std::string fname(input.file_name_);
++    std::string src(input.source_);
+ 
+     try {
+-        auto ast = input.isModule ? parser_->ParseModule(fname, src) : parser_->ParseScript(fname, src);
++        auto ast = input.is_module_ ? parser_->ParseModule(fname, src) : parser_->ParseScript(fname, src);
+ 
+-        if (options.dumpAst) {
++        if (options.dump_ast_) {
+             std::cout << ast.Dump() << std::endl;
+         }
+ 
+-        if (options.parseOnly) {
++        if (options.parse_only_) {
+             return nullptr;
+         }
+ 
+diff --git a/es2panda.h b/es2panda.h
+index f68866c..52459b5 100644
+--- a/es2panda.h
++++ b/es2panda.h
+@@ -40,20 +40,20 @@ enum class ScriptExtension {
+ };
+ 
+ struct SourceFile {
+-    SourceFile(std::string_view fn, std::string_view s) : fileName(fn), source(s) {};
+-    SourceFile(std::string_view fn, std::string_view s, bool m) : fileName(fn), source(s), isModule(m) {};
++    SourceFile(std::string_view fn, std::string_view s) : file_name_(fn), source_(s) {};
++    SourceFile(std::string_view fn, std::string_view s, bool m) : file_name_(fn), source_(s), is_module_(m) {};
+ 
+-    std::string_view fileName {};
+-    std::string_view source {};
+-    bool isModule {false};
++    std::string_view file_name_ {};
++    std::string_view source_ {};
++    bool is_module_ {false};
+ };
+ 
+ struct CompilerOptions {
+-    bool isDebug {false};
+-    bool dumpAst {false};
+-    bool dumpAsm {false};
+-    bool dumpDebugInfo {false};
+-    bool parseOnly {false};
++    bool is_debug_ {false};
++    bool dump_ast_ {false};
++    bool dump_asm_ {false};
++    bool dump_debug_info_ {false};
++    bool parse_only_ {false};
+ };
+ 
+ enum class ErrorType {
+@@ -100,7 +100,7 @@ public:
+ 
+     int ErrorCode() const noexcept
+     {
+-        return errorCode_;
++        return error_code_;
+     }
+ 
+     const std::string &Message() const noexcept
+@@ -123,7 +123,7 @@ private:
+     std::string message_;
+     size_t line_ {};
+     size_t col_ {};
+-    int errorCode_ {1};
++    int error_code_ {1};
+ };
+ 
+ class Compiler {
+diff --git a/ir/astDump.cpp b/ir/astDump.cpp
+index fceef8a..71e0b61 100644
+--- a/ir/astDump.cpp
++++ b/ir/astDump.cpp
+@@ -213,10 +213,10 @@ void AstDumper::SerializeLoc(const lexer::SourceRange &loc)
+ 
+     Wrap([this, &loc]() -> void {
+         SerializePropKey("start");
+-        SerializeSourcePosition(loc.start);
++        SerializeSourcePosition(loc.start_);
+         ss_ << ',';
+         SerializePropKey("end");
+-        SerializeSourcePosition(loc.end);
++        SerializeSourcePosition(loc.end_);
+     });
+ }
+ 
+@@ -226,10 +226,10 @@ void AstDumper::SerializeSourcePosition(const lexer::SourcePosition &pos)
+ 
+     Wrap([this, &loc]() -> void {
+         SerializePropKey("line");
+-        SerializeNumber(loc.line);
++        SerializeNumber(loc.line_);
+         ss_ << ',';
+         SerializePropKey("column");
+-        SerializeNumber(loc.col);
++        SerializeNumber(loc.col_);
+     });
+ }
+ 
+diff --git a/ir/astNode.h b/ir/astNode.h
+index 31f55da..2285456 100644
+--- a/ir/astNode.h
++++ b/ir/astNode.h
+@@ -214,22 +214,22 @@ public:
+ 
+     void SetStart(const lexer::SourcePosition &start)
+     {
+-        range_.start = start;
++        range_.start_ = start;
+     }
+ 
+     void SetEnd(const lexer::SourcePosition &end)
+     {
+-        range_.end = end;
++        range_.end_ = end;
+     }
+ 
+     const lexer::SourcePosition &Start() const
+     {
+-        return range_.start;
++        return range_.start_;
+     }
+ 
+     const lexer::SourcePosition &End() const
+     {
+-        return range_.end;
++        return range_.end_;
+     }
+ 
+     const lexer::SourceRange &Range() const
+diff --git a/ir/base/classDefinition.cpp b/ir/base/classDefinition.cpp
+index bd18a40..7cbdbc8 100644
+--- a/ir/base/classDefinition.cpp
++++ b/ir/base/classDefinition.cpp
+@@ -51,16 +51,16 @@ void ClassDefinition::Iterate(const NodeTraverser &cb) const
+         cb(ident_);
+     }
+ 
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+-    if (superClass_) {
+-        cb(superClass_);
++    if (super_class_) {
++        cb(super_class_);
+     }
+ 
+-    if (superTypeParams_) {
+-        cb(superTypeParams_);
++    if (super_type_params_) {
++        cb(super_type_params_);
+     }
+ 
+     for (auto *it : implements_) {
+@@ -73,7 +73,7 @@ void ClassDefinition::Iterate(const NodeTraverser &cb) const
+         cb(it);
+     }
+ 
+-    for (auto *it : indexSignatures_) {
++    for (auto *it : index_signatures_) {
+         cb(it);
+     }
+ }
+@@ -81,21 +81,21 @@ void ClassDefinition::Iterate(const NodeTraverser &cb) const
+ void ClassDefinition::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"id", AstDumper::Nullable(ident_)},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)},
+-                 {"superClass", AstDumper::Nullable(superClass_)},
+-                 {"superTypeParameters", AstDumper::Optional(superTypeParams_)},
++                 {"typeParameters", AstDumper::Optional(type_params_)},
++                 {"superClass", AstDumper::Nullable(super_class_)},
++                 {"superTypeParameters", AstDumper::Optional(super_type_params_)},
+                  {"implements", implements_},
+                  {"constructor", ctor_},
+                  {"body", body_},
+-                 {"indexSignatures", indexSignatures_}});
++                 {"indexSignatures", index_signatures_}});
+ }
+ 
+ compiler::VReg ClassDefinition::CompileHeritageClause(compiler::PandaGen *pg) const
+ {
+     compiler::VReg baseReg = pg->AllocReg();
+ 
+-    if (superClass_) {
+-        superClass_->Compile(pg);
++    if (super_class_) {
++        super_class_->Compile(pg);
+     } else {
+         pg->LoadConst(this, compiler::Constant::JS_HOLE);
+     }
+diff --git a/ir/base/classDefinition.h b/ir/base/classDefinition.h
+index 32a1e30..d850d49 100644
+--- a/ir/base/classDefinition.h
++++ b/ir/base/classDefinition.h
+@@ -53,13 +53,13 @@ public:
+         : AstNode(AstNodeType::CLASS_DEFINITION),
+           scope_(scope),
+           ident_(ident),
+-          typeParams_(typeParams),
+-          superTypeParams_(superTypeParams),
++          type_params_(typeParams),
++          super_type_params_(superTypeParams),
+           implements_(std::move(implements)),
+           ctor_(ctor),
+-          superClass_(superClass),
++          super_class_(superClass),
+           body_(std::move(body)),
+-          indexSignatures_(std::move(indexSignatures)),
++          index_signatures_(std::move(indexSignatures)),
+           declare_(declare),
+           abstract_(abstract)
+     {
+@@ -77,12 +77,12 @@ public:
+ 
+     Expression *Super()
+     {
+-        return superClass_;
++        return super_class_;
+     }
+ 
+     const Expression *Super() const
+     {
+-        return superClass_;
++        return super_class_;
+     }
+ 
+     bool Declare() const
+@@ -126,13 +126,13 @@ private:
+ 
+     binder::LocalScope *scope_;
+     Identifier *ident_;
+-    TSTypeParameterDeclaration *typeParams_;
+-    TSTypeParameterInstantiation *superTypeParams_;
++    TSTypeParameterDeclaration *type_params_;
++    TSTypeParameterInstantiation *super_type_params_;
+     ArenaVector<TSClassImplements *> implements_;
+     MethodDefinition *ctor_;
+-    Expression *superClass_;
++    Expression *super_class_;
+     ArenaVector<Statement *> body_;
+-    ArenaVector<TSIndexSignature *> indexSignatures_;
++    ArenaVector<TSIndexSignature *> index_signatures_;
+     bool declare_;
+     bool abstract_;
+ };
+diff --git a/ir/base/classProperty.cpp b/ir/base/classProperty.cpp
+index b39f7f2..ca462f5 100644
+--- a/ir/base/classProperty.cpp
++++ b/ir/base/classProperty.cpp
+@@ -32,8 +32,8 @@ void ClassProperty::Iterate(const NodeTraverser &cb) const
+         cb(value_);
+     }
+ 
+-    if (typeAnnotation_) {
+-        cb(typeAnnotation_);
++    if (type_annotation_) {
++        cb(type_annotation_);
+     }
+ 
+     for (auto *it : decorators_) {
+@@ -52,8 +52,8 @@ void ClassProperty::Dump(ir::AstDumper *dumper) const
+                  {"readonly", (modifiers_ & ModifierFlags::READONLY) != 0},
+                  {"declare", (modifiers_ & ModifierFlags::DECLARE) != 0},
+                  {"optional", (modifiers_ & ModifierFlags::OPTIONAL) != 0},
+-                 {"computed", isComputed_},
+-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
++                 {"computed", is_computed_},
++                 {"typeAnnotation", AstDumper::Optional(type_annotation_)},
+                  {"definite", AstDumper::Optional(definite_)},
+                  {"decorators", decorators_}});
+ }
+diff --git a/ir/base/classProperty.h b/ir/base/classProperty.h
+index e1bc499..17523a6 100644
+--- a/ir/base/classProperty.h
++++ b/ir/base/classProperty.h
+@@ -38,10 +38,10 @@ public:
+         : Statement(AstNodeType::CLASS_PROPERTY),
+           key_(key),
+           value_(value),
+-          typeAnnotation_(typeAnnotation),
++          type_annotation_(typeAnnotation),
+           modifiers_(modifiers),
+           decorators_(std::move(decorators)),
+-          isComputed_(isComputed),
++          is_computed_(isComputed),
+           definite_(definite)
+     {
+     }
+@@ -58,7 +58,7 @@ public:
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     ModifierFlags Modifiers() const
+@@ -73,7 +73,7 @@ public:
+ 
+     bool IsComputed() const
+     {
+-        return isComputed_;
++        return is_computed_;
+     }
+ 
+     bool Definite() const
+@@ -89,10 +89,10 @@ public:
+ private:
+     Expression *key_;
+     Expression *value_;
+-    Expression *typeAnnotation_;
++    Expression *type_annotation_;
+     ModifierFlags modifiers_;
+     ArenaVector<Decorator *> decorators_;
+-    bool isComputed_;
++    bool is_computed_;
+     bool definite_;
+ };
+ 
+diff --git a/ir/base/methodDefinition.cpp b/ir/base/methodDefinition.cpp
+index a3798ec..2f4b1a7 100644
+--- a/ir/base/methodDefinition.cpp
++++ b/ir/base/methodDefinition.cpp
+@@ -76,7 +76,7 @@ void MethodDefinition::Dump(ir::AstDumper *dumper) const
+                  {"accessibility", AstDumper::Optional(AstDumper::ModifierToString(modifiers_))},
+                  {"static", (modifiers_ & ModifierFlags::STATIC) != 0},
+                  {"optional", (modifiers_ & ModifierFlags::OPTIONAL) != 0},
+-                 {"computed", isComputed_},
++                 {"computed", is_computed_},
+                  {"value", value_},
+                  {"overloads", overloads_},
+                  {"decorators", decorators_}});
+diff --git a/ir/base/methodDefinition.h b/ir/base/methodDefinition.h
+index e304cd0..73252f5 100644
+--- a/ir/base/methodDefinition.h
++++ b/ir/base/methodDefinition.h
+@@ -46,7 +46,7 @@ public:
+           modifiers_(modifiers),
+           overloads_(allocator->Adapter()),
+           decorators_(std::move(decorators)),
+-          isComputed_(isComputed)
++          is_computed_(isComputed)
+     {
+     }
+ 
+@@ -72,7 +72,7 @@ public:
+ 
+     bool Computed() const
+     {
+-        return isComputed_;
++        return is_computed_;
+     }
+ 
+     bool IsStatic() const
+@@ -119,7 +119,7 @@ private:
+     ModifierFlags modifiers_;
+     ArenaVector<MethodDefinition *> overloads_;
+     ArenaVector<Decorator *> decorators_;
+-    bool isComputed_;
++    bool is_computed_;
+ };
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/base/property.cpp b/ir/base/property.cpp
+index 5802e38..51b3ddf 100644
+--- a/ir/base/property.cpp
++++ b/ir/base/property.cpp
+@@ -29,7 +29,7 @@ namespace panda::es2panda::ir {
+ bool Property::ConventibleToPatternProperty()
+ {
+     // Object pattern can't contain getter or setter
+-    if (IsAccessor() || isMethod_) {
++    if (IsAccessor() || is_method_) {
+         return false;
+     }
+ 
+@@ -120,9 +120,9 @@ void Property::Dump(ir::AstDumper *dumper) const
+     }
+ 
+     dumper->Add({{"type", "Property"},
+-                 {"method", isMethod_},
+-                 {"shorthand", isShorthand_},
+-                 {"computed", isComputed_},
++                 {"method", is_method_},
++                 {"shorthand", is_shorthand_},
++                 {"computed", is_computed_},
+                  {"key", key_},
+                  {"value", value_},
+                  {"kind", kind}});
+diff --git a/ir/base/property.h b/ir/base/property.h
+index f47df4b..a0b6ec8 100644
+--- a/ir/base/property.h
++++ b/ir/base/property.h
+@@ -39,9 +39,9 @@ public:
+           kind_(PropertyKind::INIT),
+           key_(key),
+           value_(value),
+-          isMethod_(false),
+-          isShorthand_(true),
+-          isComputed_(false)
++          is_method_(false),
++          is_shorthand_(true),
++          is_computed_(false)
+     {
+     }
+ 
+@@ -50,9 +50,9 @@ public:
+           kind_(kind),
+           key_(key),
+           value_(value),
+-          isMethod_(isMethod),
+-          isShorthand_(false),
+-          isComputed_(isComputed)
++          is_method_(isMethod),
++          is_shorthand_(false),
++          is_computed_(isComputed)
+     {
+     }
+ 
+@@ -83,17 +83,17 @@ public:
+ 
+     bool IsMethod() const
+     {
+-        return isMethod_;
++        return is_method_;
+     }
+ 
+     bool IsShorthand() const
+     {
+-        return isShorthand_;
++        return is_shorthand_;
+     }
+ 
+     bool IsComputed() const
+     {
+-        return isComputed_;
++        return is_computed_;
+     }
+ 
+     bool IsAccessor() const
+@@ -117,9 +117,9 @@ private:
+     PropertyKind kind_;
+     Expression *key_;
+     Expression *value_;
+-    bool isMethod_;
+-    bool isShorthand_;
+-    bool isComputed_;
++    bool is_method_;
++    bool is_shorthand_;
++    bool is_computed_;
+ };
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/base/scriptFunction.cpp b/ir/base/scriptFunction.cpp
+index d4d0678..63f92ad 100644
+--- a/ir/base/scriptFunction.cpp
++++ b/ir/base/scriptFunction.cpp
+@@ -46,8 +46,8 @@ void ScriptFunction::Iterate(const NodeTraverser &cb) const
+         cb(id_);
+     }
+ 
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+     for (auto *it : params_) {
+@@ -67,8 +67,8 @@ void ScriptFunction::Dump(ir::AstDumper *dumper) const
+                  {"async", IsAsync()},
+                  {"expression", ((flags_ & ir::ScriptFunctionFlags::EXPRESSION) != 0)},
+                  {"params", params_},
+-                 {"returnType", AstDumper::Optional(returnTypeAnnotation_)},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)},
++                 {"returnType", AstDumper::Optional(return_type_annotation_)},
++                 {"typeParameters", AstDumper::Optional(type_params_)},
+                  {"declare", AstDumper::Optional(declare_)},
+                  {"body", AstDumper::Optional(body_)}});
+ }
+diff --git a/ir/base/scriptFunction.h b/ir/base/scriptFunction.h
+index 3e3a35e..59bf362 100644
+--- a/ir/base/scriptFunction.h
++++ b/ir/base/scriptFunction.h
+@@ -44,9 +44,9 @@ public:
+         : AstNode(AstNodeType::SCRIPT_FUNCTION),
+           scope_(scope),
+           params_(std::move(params)),
+-          typeParams_(typeParams),
++          type_params_(typeParams),
+           body_(body),
+-          returnTypeAnnotation_(returnTypeAnnotation),
++          return_type_annotation_(returnTypeAnnotation),
+           flags_(flags),
+           declare_(declare)
+     {
+@@ -74,7 +74,7 @@ public:
+ 
+     const TSTypeParameterDeclaration *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     const AstNode *Body() const
+@@ -89,7 +89,7 @@ public:
+ 
+     const Expression *ReturnTypeAnnotation() const
+     {
+-        return returnTypeAnnotation_;
++        return return_type_annotation_;
+     }
+ 
+     bool IsGenerator() const
+@@ -153,9 +153,9 @@ private:
+     binder::FunctionScope *scope_;
+     Identifier *id_ {nullptr};
+     ArenaVector<Expression *> params_;
+-    TSTypeParameterDeclaration *typeParams_;
++    TSTypeParameterDeclaration *type_params_;
+     AstNode *body_;
+-    Expression *returnTypeAnnotation_;
++    Expression *return_type_annotation_;
+     ir::ScriptFunctionFlags flags_;
+     bool declare_;
+ };
+diff --git a/ir/base/spreadElement.cpp b/ir/base/spreadElement.cpp
+index fec7cea..fac5a5e 100644
+--- a/ir/base/spreadElement.cpp
++++ b/ir/base/spreadElement.cpp
+@@ -76,15 +76,15 @@ bool SpreadElement::ConvertibleToRest(bool isDeclaration, bool allowPattern)
+ 
+ void SpreadElement::SetTsTypeAnnotation(Expression *typeAnnotation)
+ {
+-    typeAnnotation_ = typeAnnotation;
++    type_annotation_ = typeAnnotation;
+ }
+ 
+ void SpreadElement::Iterate(const NodeTraverser &cb) const
+ {
+     cb(argument_);
+ 
+-    if (typeAnnotation_) {
+-        cb(typeAnnotation_);
++    if (type_annotation_) {
++        cb(type_annotation_);
+     }
+ }
+ 
+@@ -92,7 +92,7 @@ void SpreadElement::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", (type_ == AstNodeType::SPREAD_ELEMENT) ? "SpreadElement" : "RestElement"},
+                  {"argument", argument_},
+-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)}});
++                 {"typeAnnotation", AstDumper::Optional(type_annotation_)}});
+ }
+ 
+ void SpreadElement::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/base/spreadElement.h b/ir/base/spreadElement.h
+index 858ef01..bb2d353 100644
+--- a/ir/base/spreadElement.h
++++ b/ir/base/spreadElement.h
+@@ -46,7 +46,7 @@ public:
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     ValidationInfo ValidateExpression();
+@@ -60,7 +60,7 @@ public:
+ 
+ private:
+     Expression *argument_;
+-    Expression *typeAnnotation_ {};
++    Expression *type_annotation_ {};
+ };
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/expressions/arrayExpression.cpp b/ir/expressions/arrayExpression.cpp
+index c2f56bb..08fd7f3 100644
+--- a/ir/expressions/arrayExpression.cpp
++++ b/ir/expressions/arrayExpression.cpp
+@@ -37,8 +37,8 @@ bool ArrayExpression::ConvertibleToArrayPattern()
+                 break;
+             }
+             case AstNodeType::SPREAD_ELEMENT: {
+-                if (!restFound && it == elements_.back() && !trailingComma_) {
+-                    convResult = it->AsSpreadElement()->ConvertibleToRest(isDeclaration_);
++                if (!restFound && it == elements_.back() && !trailing_comma_) {
++                    convResult = it->AsSpreadElement()->ConvertibleToRest(is_declaration_);
+                 } else {
+                     convResult = false;
+                 }
+@@ -121,8 +121,8 @@ void ArrayExpression::Iterate(const NodeTraverser &cb) const
+         cb(it);
+     }
+ 
+-    if (typeAnnotation_) {
+-        cb(typeAnnotation_);
++    if (type_annotation_) {
++        cb(type_annotation_);
+     }
+ }
+ 
+@@ -130,7 +130,7 @@ void ArrayExpression::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", type_ == AstNodeType::ARRAY_EXPRESSION ? "ArrayExpression" : "ArrayPattern"},
+                  {"elements", elements_},
+-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
++                 {"typeAnnotation", AstDumper::Optional(type_annotation_)},
+                  {"optional", AstDumper::Optional(optional_)}});
+ }
+ 
+@@ -260,7 +260,7 @@ checker::Type *ArrayExpression::Check(checker::Checker *checker) const
+             memberVar->AddFlag(binder::VariableFlags::PROPERTY);
+             memberVar->SetTsType(currentElementType);
+             elementFlags.insert({memberIndex, checker::ElementFlags::REQUIRED});
+-            desc->properties.push_back(memberVar);
++            desc->properties_.push_back(memberVar);
+             index++;
+         }
+ 
+@@ -286,7 +286,7 @@ checker::Type *ArrayExpression::Check(checker::Checker *checker) const
+ 
+     if (forceTuple) {
+         // TODO(aszilagyi): handle readonly when creating IndexInfo and TupleType
+-        desc->numberIndexInfo = checker->Allocator()->New<checker::IndexInfo>(arrayElementType, "x", false);
++        desc->number_index_info_ = checker->Allocator()->New<checker::IndexInfo>(arrayElementType, "x", false);
+         return checker->CreateTupleType(desc, std::move(elementFlags), checker::ElementFlags::REQUIRED, index, index,
+                                         false);
+     }
+@@ -346,13 +346,13 @@ checker::Type *ArrayExpression::CheckPattern(checker::Checker *checker) const
+ 
+         memberVar->SetTsType(elementType);
+         elementFlags.insert({memberIndex, memberFlag});
+-        desc->properties.push_back(memberVar);
++        desc->properties_.push_back(memberVar);
+ 
+         combinedFlags |= memberFlag;
+         index++;
+     }
+ 
+-    return checker->CreateTupleType(desc, std::move(elementFlags), combinedFlags, minLength, desc->properties.size(),
++    return checker->CreateTupleType(desc, std::move(elementFlags), combinedFlags, minLength, desc->properties_.size(),
+                                     false);
+ }
+ 
+diff --git a/ir/expressions/arrayExpression.h b/ir/expressions/arrayExpression.h
+index 895ba84..5dbf434 100644
+--- a/ir/expressions/arrayExpression.h
++++ b/ir/expressions/arrayExpression.h
+@@ -34,7 +34,7 @@ namespace panda::es2panda::ir {
+ class ArrayExpression : public Expression {
+ public:
+     explicit ArrayExpression(AstNodeType nodeType, ArenaVector<Expression *> &&elements, bool trailingComma)
+-        : Expression(nodeType), elements_(std::move(elements)), trailingComma_(trailingComma)
++        : Expression(nodeType), elements_(std::move(elements)), trailing_comma_(trailingComma)
+     {
+     }
+ 
+@@ -45,12 +45,12 @@ public:
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     bool IsDeclaration() const
+     {
+-        return isDeclaration_;
++        return is_declaration_;
+     }
+ 
+     bool Optional() const
+@@ -60,7 +60,7 @@ public:
+ 
+     void SetDeclaration()
+     {
+-        isDeclaration_ = true;
++        is_declaration_ = true;
+     }
+ 
+     void SetOptional(bool optional)
+@@ -73,7 +73,7 @@ public:
+ 
+     void SetTsTypeAnnotation(Expression *typeAnnotation) override
+     {
+-        typeAnnotation_ = typeAnnotation;
++        type_annotation_ = typeAnnotation;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -84,9 +84,9 @@ public:
+ 
+ private:
+     ArenaVector<Expression *> elements_;
+-    Expression *typeAnnotation_ {nullptr};
+-    bool isDeclaration_ {};
+-    bool trailingComma_;
++    Expression *type_annotation_ {nullptr};
++    bool is_declaration_ {};
++    bool trailing_comma_;
+     bool optional_ {false};
+ };
+ 
+diff --git a/ir/expressions/arrowFunctionExpression.cpp b/ir/expressions/arrowFunctionExpression.cpp
+index 0a3ac18..6821c91 100644
+--- a/ir/expressions/arrowFunctionExpression.cpp
++++ b/ir/expressions/arrowFunctionExpression.cpp
+@@ -54,9 +54,9 @@ checker::Type *ArrowFunctionExpression::Check([[maybe_unused]] checker::Checker
+             const util::StringView &varName = varDecl->AsVariableDeclarator()->Id()->AsIdentifier()->Name();
+ 
+             binder::ScopeFindResult result = checker->Scope()->Find(varName);
+-            ASSERT(result.variable);
++            ASSERT(result.variable_);
+ 
+-            funcVar = result.variable;
++            funcVar = result.variable_;
+         }
+     }
+ 
+@@ -73,7 +73,7 @@ checker::Type *ArrowFunctionExpression::Check([[maybe_unused]] checker::Checker
+         returnType = funcVar->TsType();
+     } else {
+         checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+-        desc->callSignatures.push_back(checker->HandleFunctionReturn(func_, signatureInfo, funcVar));
++        desc->call_signatures_.push_back(checker->HandleFunctionReturn(func_, signatureInfo, funcVar));
+         returnType = checker->Allocator()->New<checker::FunctionType>(desc);
+     }
+ 
+diff --git a/ir/expressions/callExpression.cpp b/ir/expressions/callExpression.cpp
+index bebd28a..f02cb7f 100644
+--- a/ir/expressions/callExpression.cpp
++++ b/ir/expressions/callExpression.cpp
+@@ -32,8 +32,8 @@ void CallExpression::Iterate(const NodeTraverser &cb) const
+ {
+     cb(callee_);
+ 
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+     for (auto *it : arguments_) {
+@@ -47,7 +47,7 @@ void CallExpression::Dump(ir::AstDumper *dumper) const
+                  {"callee", callee_},
+                  {"arguments", arguments_},
+                  {"optional", optional_},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)}});
++                 {"typeParameters", AstDumper::Optional(type_params_)}});
+ }
+ 
+ compiler::VReg CallExpression::CreateSpreadArguments(compiler::PandaGen *pg) const
+diff --git a/ir/expressions/callExpression.h b/ir/expressions/callExpression.h
+index c49d17f..3415c8a 100644
+--- a/ir/expressions/callExpression.h
++++ b/ir/expressions/callExpression.h
+@@ -39,7 +39,7 @@ public:
+         : Expression(AstNodeType::CALL_EXPRESSION),
+           callee_(callee),
+           arguments_(std::move(arguments)),
+-          typeParams_(typeParams),
++          type_params_(typeParams),
+           optional_(optional)
+     {
+     }
+@@ -51,7 +51,7 @@ public:
+ 
+     const TSTypeParameterInstantiation *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     const ArenaVector<Expression *> &Arguments() const
+@@ -66,7 +66,7 @@ public:
+ 
+     void SetTypeParams(TSTypeParameterInstantiation *typeParams)
+     {
+-        typeParams_ = typeParams;
++        type_params_ = typeParams;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -79,7 +79,7 @@ private:
+ 
+     Expression *callee_;
+     ArenaVector<Expression *> arguments_;
+-    TSTypeParameterInstantiation *typeParams_;
++    TSTypeParameterInstantiation *type_params_;
+     bool optional_;
+ };
+ 
+diff --git a/ir/expressions/functionExpression.cpp b/ir/expressions/functionExpression.cpp
+index c8a28b2..c7d5f88 100644
+--- a/ir/expressions/functionExpression.cpp
++++ b/ir/expressions/functionExpression.cpp
+@@ -54,9 +54,9 @@ checker::Type *FunctionExpression::Check(checker::Checker *checker) const
+             const util::StringView &varName = varDecl->AsVariableDeclarator()->Id()->AsIdentifier()->Name();
+ 
+             binder::ScopeFindResult result = checker->Scope()->Find(varName);
+-            ASSERT(result.variable);
++            ASSERT(result.variable_);
+ 
+-            funcVar = result.variable;
++            funcVar = result.variable_;
+         }
+     }
+ 
+@@ -72,7 +72,7 @@ checker::Type *FunctionExpression::Check(checker::Checker *checker) const
+         returnType = funcVar->TsType();
+     } else {
+         checker::ObjectDescriptor *desc = checker->Allocator()->New<checker::ObjectDescriptor>();
+-        desc->callSignatures.push_back(checker->HandleFunctionReturn(func_, signatureInfo, funcVar));
++        desc->call_signatures_.push_back(checker->HandleFunctionReturn(func_, signatureInfo, funcVar));
+         returnType = checker->Allocator()->New<checker::FunctionType>(desc);
+     }
+ 
+diff --git a/ir/expressions/identifier.cpp b/ir/expressions/identifier.cpp
+index 0132d87..8e2fee7 100644
+--- a/ir/expressions/identifier.cpp
++++ b/ir/expressions/identifier.cpp
+@@ -26,8 +26,8 @@ namespace panda::es2panda::ir {
+ 
+ void Identifier::Iterate(const NodeTraverser &cb) const
+ {
+-    if (typeAnnotation_) {
+-        cb(typeAnnotation_);
++    if (type_annotation_) {
++        cb(type_annotation_);
+     }
+ 
+     for (auto *it : decorators_) {
+@@ -39,7 +39,7 @@ void Identifier::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "Identifier"},
+                  {"name", name_},
+-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
++                 {"typeAnnotation", AstDumper::Optional(type_annotation_)},
+                  {"optional", AstDumper::Optional(IsOptional())},
+                  {"decorators", decorators_}});
+ }
+@@ -47,7 +47,7 @@ void Identifier::Dump(ir::AstDumper *dumper) const
+ void Identifier::Compile(compiler::PandaGen *pg) const
+ {
+     binder::ScopeFindResult res = pg->Scope()->Find(name_);
+-    if (res.variable) {
++    if (res.variable_) {
+         pg->LoadVar(this, res);
+         return;
+     }
+diff --git a/ir/expressions/identifier.h b/ir/expressions/identifier.h
+index 2cfdf04..ea7cc53 100644
+--- a/ir/expressions/identifier.h
++++ b/ir/expressions/identifier.h
+@@ -58,14 +58,14 @@ public:
+     explicit Identifier(util::StringView name, Expression *typeAnnotation, ArenaAllocator *allocator)
+         : Expression(AstNodeType::IDENTIFIER),
+           name_(name),
+-          typeAnnotation_(typeAnnotation),
++          type_annotation_(typeAnnotation),
+           decorators_(allocator->Adapter())
+     {
+     }
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     const util::StringView &Name() const
+@@ -114,7 +114,7 @@ public:
+ 
+     void SetTsTypeAnnotation(Expression *typeAnnotation) override
+     {
+-        typeAnnotation_ = typeAnnotation;
++        type_annotation_ = typeAnnotation;
+     }
+ 
+     binder::Variable *Variable() const
+@@ -134,7 +134,7 @@ public:
+ 
+ private:
+     util::StringView name_;
+-    Expression *typeAnnotation_ {};
++    Expression *type_annotation_ {};
+     IdentifierFlags flags_ {IdentifierFlags::NONE};
+     ArenaVector<Decorator *> decorators_;
+     binder::Variable *variable_ {nullptr};
+diff --git a/ir/expressions/objectExpression.cpp b/ir/expressions/objectExpression.cpp
+index bb4e2f6..d6bb2bb 100644
+--- a/ir/expressions/objectExpression.cpp
++++ b/ir/expressions/objectExpression.cpp
+@@ -90,8 +90,8 @@ bool ObjectExpression::ConvertibleToObjectPattern()
+                 break;
+             }
+             case AstNodeType::SPREAD_ELEMENT: {
+-                if (!restFound && it == properties_.back() && !trailingComma_) {
+-                    convResult = it->AsSpreadElement()->ConvertibleToRest(isDeclaration_, false);
++                if (!restFound && it == properties_.back() && !trailing_comma_) {
++                    convResult = it->AsSpreadElement()->ConvertibleToRest(is_declaration_, false);
+                 } else {
+                     convResult = false;
+                 }
+@@ -133,7 +133,7 @@ bool ObjectExpression::ConvertibleToObjectPattern()
+ 
+ void ObjectExpression::SetDeclaration()
+ {
+-    isDeclaration_ = true;
++    is_declaration_ = true;
+ }
+ 
+ void ObjectExpression::SetOptional(bool optional)
+@@ -143,7 +143,7 @@ void ObjectExpression::SetOptional(bool optional)
+ 
+ void ObjectExpression::SetTsTypeAnnotation(Expression *typeAnnotation)
+ {
+-    typeAnnotation_ = typeAnnotation;
++    type_annotation_ = typeAnnotation;
+ }
+ 
+ void ObjectExpression::Iterate(const NodeTraverser &cb) const
+@@ -152,8 +152,8 @@ void ObjectExpression::Iterate(const NodeTraverser &cb) const
+         cb(it);
+     }
+ 
+-    if (typeAnnotation_) {
+-        cb(typeAnnotation_);
++    if (type_annotation_) {
++        cb(type_annotation_);
+     }
+ }
+ 
+@@ -161,7 +161,7 @@ void ObjectExpression::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", (type_ == AstNodeType::OBJECT_EXPRESSION) ? "ObjectExpression" : "ObjectPattern"},
+                  {"properties", properties_},
+-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
++                 {"typeAnnotation", AstDumper::Optional(type_annotation_)},
+                  {"optional", AstDumper::Optional(optional_)}});
+ }
+ 
+@@ -382,8 +382,8 @@ static void CheckPatternProperty(checker::Checker *checker, bool inAssignment, c
+         optional = true;
+     } else if (inAssignment) {
+         binder::ScopeFindResult result = checker->Scope()->Find(propName);
+-        if (result.variable) {
+-            propType = result.variable->TsType();
++        if (result.variable_) {
++            propType = result.variable_->TsType();
+         }
+     }
+ 
+@@ -394,7 +394,7 @@ static void CheckPatternProperty(checker::Checker *checker, bool inAssignment, c
+     }
+ 
+     newProp->SetTsType(propType);
+-    desc->properties.push_back(newProp);
++    desc->properties_.push_back(newProp);
+ }
+ 
+ checker::Type *ObjectExpression::CheckPattern(checker::Checker *checker, bool inAssignment) const
+@@ -408,7 +408,7 @@ checker::Type *ObjectExpression::CheckPattern(checker::Checker *checker, bool in
+             haveRest = true;
+             util::StringView indexInfoName("x");
+             auto *newIndexInfo = checker->Allocator()->New<checker::IndexInfo>(checker->GlobalAnyType(), indexInfoName);
+-            desc->stringIndexInfo = newIndexInfo;
++            desc->string_index_info_ = newIndexInfo;
+         } else {
+             CheckPatternProperty(checker, inAssignment, desc, it);
+         }
+@@ -435,25 +435,25 @@ checker::Type *ObjectExpression::Check(checker::Checker *checker) const
+         if (it->IsProperty()) {
+             checker::ObjectLiteralPropertyInfo propInfo =
+                 checker->HandleObjectLiteralProperty(it->AsProperty(), desc, &stringIndexTypes, readonly);
+-            if (propInfo.handleNextProp) {
++            if (propInfo.handle_next_prop_) {
+                 continue;
+             }
+ 
+-            if (desc->FindProperty(propInfo.propName)) {
+-                checker->ThrowTypeError({"Duplicate identifier '", propInfo.propName, "'."}, it->Start());
++            if (desc->FindProperty(propInfo.prop_name_)) {
++                checker->ThrowTypeError({"Duplicate identifier '", propInfo.prop_name_, "'."}, it->Start());
+             }
+ 
+-            propInfo.propType = checker->GetBaseTypeOfLiteralType(propInfo.propType);
++            propInfo.prop_type_ = checker->GetBaseTypeOfLiteralType(propInfo.prop_type_);
+             binder::VariableFlags propFlag =
+                 it->AsProperty()->IsMethod() ? binder::VariableFlags::METHOD : binder::VariableFlags::PROPERTY;
+-            auto *newProp = binder::Scope::CreateVar(checker->Allocator(), propInfo.propName, propFlag, it);
++            auto *newProp = binder::Scope::CreateVar(checker->Allocator(), propInfo.prop_name_, propFlag, it);
+ 
+-            propInfo.propType->SetVariable(newProp);
+-            newProp->SetTsType(propInfo.propType);
++            propInfo.prop_type_->SetVariable(newProp);
++            newProp->SetTsType(propInfo.prop_type_);
+             if (readonly) {
+-                propInfo.propType->Variable()->AddFlag(binder::VariableFlags::READONLY);
++                propInfo.prop_type_->Variable()->AddFlag(binder::VariableFlags::READONLY);
+             }
+-            desc->properties.push_back(newProp);
++            desc->properties_.push_back(newProp);
+         } else {
+             ASSERT(it->IsSpreadElement());
+             checker->HandleSpreadElement(it->AsSpreadElement(), desc, it->Start(), readonly);
+@@ -464,7 +464,7 @@ checker::Type *ObjectExpression::Check(checker::Checker *checker) const
+ 
+     if (stringIndexType) {
+         auto *strIndexInfo = checker->Allocator()->New<checker::IndexInfo>(stringIndexType, "x", readonly);
+-        desc->stringIndexInfo = strIndexInfo;
++        desc->string_index_info_ = strIndexInfo;
+     }
+ 
+     return checker->Allocator()->New<checker::ObjectLiteralType>(desc);
+diff --git a/ir/expressions/objectExpression.h b/ir/expressions/objectExpression.h
+index 741db11..8d6735e 100644
+--- a/ir/expressions/objectExpression.h
++++ b/ir/expressions/objectExpression.h
+@@ -39,7 +39,7 @@ namespace panda::es2panda::ir {
+ class ObjectExpression : public Expression {
+ public:
+     explicit ObjectExpression(AstNodeType nodeType, ArenaVector<Expression *> &&properties, bool trailingComma)
+-        : Expression(nodeType), properties_(std::move(properties)), trailingComma_(trailingComma)
++        : Expression(nodeType), properties_(std::move(properties)), trailing_comma_(trailingComma)
+     {
+     }
+ 
+@@ -50,12 +50,12 @@ public:
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     bool IsDeclaration() const
+     {
+-        return isDeclaration_;
++        return is_declaration_;
+     }
+ 
+     bool Optional() const
+@@ -81,9 +81,9 @@ private:
+     void CompileRemainingProperties(compiler::PandaGen *pg, const util::BitSet *compiled, compiler::VReg objReg) const;
+ 
+     ArenaVector<Expression *> properties_;
+-    Expression *typeAnnotation_ {nullptr};
+-    bool isDeclaration_ {};
+-    bool trailingComma_ {};
++    Expression *type_annotation_ {nullptr};
++    bool is_declaration_ {};
++    bool trailing_comma_ {};
+     bool optional_ {false};
+ };
+ 
+diff --git a/ir/expressions/taggedTemplateExpression.cpp b/ir/expressions/taggedTemplateExpression.cpp
+index 1564832..bb2f5aa 100644
+--- a/ir/expressions/taggedTemplateExpression.cpp
++++ b/ir/expressions/taggedTemplateExpression.cpp
+@@ -29,8 +29,8 @@ namespace panda::es2panda::ir {
+ 
+ void TaggedTemplateExpression::Iterate(const NodeTraverser &cb) const
+ {
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+     cb(tag_);
+@@ -42,7 +42,7 @@ void TaggedTemplateExpression::Dump(ir::AstDumper *dumper) const
+     dumper->Add({{"type", "TaggedTemplateExpression"},
+                  {"tag", tag_},
+                  {"quasi", quasi_},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)}});
++                 {"typeParameters", AstDumper::Optional(type_params_)}});
+ }
+ 
+ void TaggedTemplateExpression::Compile(compiler::PandaGen *pg) const
+diff --git a/ir/expressions/taggedTemplateExpression.h b/ir/expressions/taggedTemplateExpression.h
+index 84a4043..f6400b5 100644
+--- a/ir/expressions/taggedTemplateExpression.h
++++ b/ir/expressions/taggedTemplateExpression.h
+@@ -35,7 +35,7 @@ class TSTypeParameterInstantiation;
+ class TaggedTemplateExpression : public Expression {
+ public:
+     explicit TaggedTemplateExpression(Expression *tag, TemplateLiteral *quasi, TSTypeParameterInstantiation *typeParams)
+-        : Expression(AstNodeType::TAGGED_TEMPLATE_EXPRESSION), tag_(tag), quasi_(quasi), typeParams_(typeParams)
++        : Expression(AstNodeType::TAGGED_TEMPLATE_EXPRESSION), tag_(tag), quasi_(quasi), type_params_(typeParams)
+     {
+     }
+ 
+@@ -51,7 +51,7 @@ public:
+ 
+     const TSTypeParameterInstantiation *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -62,7 +62,7 @@ public:
+ protected:
+     Expression *tag_;
+     TemplateLiteral *quasi_;
+-    TSTypeParameterInstantiation *typeParams_;
++    TSTypeParameterInstantiation *type_params_;
+ };
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/expressions/thisExpression.cpp b/ir/expressions/thisExpression.cpp
+index 920d897..9aa42af 100644
+--- a/ir/expressions/thisExpression.cpp
++++ b/ir/expressions/thisExpression.cpp
+@@ -34,7 +34,7 @@ void ThisExpression::Compile(compiler::PandaGen *pg) const
+ {
+     binder::ScopeFindResult res = pg->Scope()->Find(binder::Binder::MANDATORY_PARAM_THIS);
+ 
+-    ASSERT(res.variable && res.variable->IsLocalVariable());
++    ASSERT(res.variable_ && res.variable_->IsLocalVariable());
+     pg->LoadAccFromLexEnv(this, res);
+ 
+     const ir::ScriptFunction *func = util::Helpers::GetContainingConstructor(this);
+diff --git a/ir/expressions/unaryExpression.cpp b/ir/expressions/unaryExpression.cpp
+index 6e6aaf5..3b01038 100644
+--- a/ir/expressions/unaryExpression.cpp
++++ b/ir/expressions/unaryExpression.cpp
+@@ -42,7 +42,7 @@ void UnaryExpression::Compile(compiler::PandaGen *pg) const
+         case lexer::TokenType::KEYW_DELETE: {
+             if (argument_->IsIdentifier()) {
+                 binder::ScopeFindResult result = pg->Scope()->Find(argument_->AsIdentifier()->Name());
+-                if (!result.variable || (result.scope->IsGlobalScope() && result.variable->IsGlobalVariable())) {
++                if (!result.variable_ || (result.scope_->IsGlobalScope() && result.variable_->IsGlobalVariable())) {
+                     compiler::RegScope rs(pg);
+                     compiler::VReg variable = pg->AllocReg();
+                     compiler::VReg global = pg->AllocReg();
+@@ -80,7 +80,7 @@ void UnaryExpression::Compile(compiler::PandaGen *pg) const
+                 const ir::Identifier *ident = argument_->AsIdentifier();
+ 
+                 binder::ScopeFindResult res = pg->Scope()->Find(ident->Name());
+-                if (!res.variable) {
++                if (!res.variable_) {
+                     compiler::RegScope rs(pg);
+                     compiler::VReg global = pg->AllocReg();
+ 
+diff --git a/ir/module/exportDefaultDeclaration.h b/ir/module/exportDefaultDeclaration.h
+index 997a8e8..236c9b8 100644
+--- a/ir/module/exportDefaultDeclaration.h
++++ b/ir/module/exportDefaultDeclaration.h
+@@ -32,7 +32,7 @@ namespace panda::es2panda::ir {
+ class ExportDefaultDeclaration : public Statement {
+ public:
+     explicit ExportDefaultDeclaration(AstNode *decl, bool exportEquals)
+-        : Statement(AstNodeType::EXPORT_DEFAULT_DECLARATION), decl_(decl), exportEquals_(exportEquals)
++        : Statement(AstNodeType::EXPORT_DEFAULT_DECLARATION), decl_(decl), export_equals_(exportEquals)
+     {
+     }
+ 
+@@ -43,7 +43,7 @@ public:
+ 
+     bool IsExportEquals() const
+     {
+-        return exportEquals_;
++        return export_equals_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -53,7 +53,7 @@ public:
+ 
+ private:
+     AstNode *decl_;
+-    bool exportEquals_;
++    bool export_equals_;
+ };
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/statements/forOfStatement.cpp b/ir/statements/forOfStatement.cpp
+index 241a63e..3f397ea 100644
+--- a/ir/statements/forOfStatement.cpp
++++ b/ir/statements/forOfStatement.cpp
+@@ -35,7 +35,8 @@ void ForOfStatement::Iterate(const NodeTraverser &cb) const
+ 
+ void ForOfStatement::Dump(ir::AstDumper *dumper) const
+ {
+-    dumper->Add({{"type", "ForOfStatement"}, {"await", isAwait_}, {"left", left_}, {"right", right_}, {"body", body_}});
++    dumper->Add(
++        {{"type", "ForOfStatement"}, {"await", is_await_}, {"left", left_}, {"right", right_}, {"body", body_}});
+ }
+ 
+ void ForOfStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+@@ -45,7 +46,7 @@ void ForOfStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+     right_->Compile(pg);
+ 
+     compiler::LabelTarget labelTarget(pg);
+-    auto iterator_type = isAwait_ ? compiler::IteratorType::ASYNC : compiler::IteratorType::SYNC;
++    auto iterator_type = is_await_ ? compiler::IteratorType::ASYNC : compiler::IteratorType::SYNC;
+     compiler::Iterator iterator(pg, this, iterator_type);
+ 
+     pg->SetLabel(this, labelTarget.ContinueTarget());
+diff --git a/ir/statements/forOfStatement.h b/ir/statements/forOfStatement.h
+index c48b5ea..0ecb752 100644
+--- a/ir/statements/forOfStatement.h
++++ b/ir/statements/forOfStatement.h
+@@ -42,7 +42,7 @@ public:
+           left_(left),
+           right_(right),
+           body_(body),
+-          isAwait_(isAwait)
++          is_await_(isAwait)
+     {
+     }
+ 
+@@ -78,7 +78,7 @@ public:
+ 
+     bool IsAwait() const
+     {
+-        return isAwait_;
++        return is_await_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -90,7 +90,7 @@ private:
+     AstNode *left_;
+     Expression *right_;
+     Statement *body_;
+-    bool isAwait_;
++    bool is_await_;
+ };
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/statements/functionDeclaration.cpp b/ir/statements/functionDeclaration.cpp
+index e07fe78..2fad345 100644
+--- a/ir/statements/functionDeclaration.cpp
++++ b/ir/statements/functionDeclaration.cpp
+@@ -46,10 +46,10 @@ checker::Type *FunctionDeclaration::Check([[maybe_unused]] checker::Checker *che
+ 
+     const util::StringView &funcName = func_->Id()->Name();
+     binder::ScopeFindResult result = checker->Scope()->Find(funcName);
+-    ASSERT(result.variable);
++    ASSERT(result.variable_);
+ 
+-    if (!result.variable->TsType()) {
+-        checker->InferFunctionDeclarationType(result.variable->Declaration()->AsFunctionDecl(), result.variable);
++    if (!result.variable_->TsType()) {
++        checker->InferFunctionDeclarationType(result.variable_->Declaration()->AsFunctionDecl(), result.variable_);
+     }
+ 
+     func_->Body()->Check(checker);
+diff --git a/ir/statements/tryStatement.cpp b/ir/statements/tryStatement.cpp
+index b5733e1..d517024 100644
+--- a/ir/statements/tryStatement.cpp
++++ b/ir/statements/tryStatement.cpp
+@@ -28,8 +28,8 @@ void TryStatement::Iterate(const NodeTraverser &cb) const
+ {
+     cb(block_);
+ 
+-    if (catchClause_) {
+-        cb(catchClause_);
++    if (catch_clause_) {
++        cb(catch_clause_);
+     }
+ 
+     if (finalizer_) {
+@@ -41,7 +41,7 @@ void TryStatement::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TryStatement"},
+                  {"block", block_},
+-                 {"handler", AstDumper::Nullable(catchClause_)},
++                 {"handler", AstDumper::Nullable(catch_clause_)},
+                  {"finalizer", AstDumper::Nullable(finalizer_)}});
+ }
+ 
+@@ -72,7 +72,7 @@ void TryStatement::CompileFinally(compiler::PandaGen *pg, compiler::TryContext *
+ 
+ void TryStatement::CompileTryCatchFinally(compiler::PandaGen *pg) const
+ {
+-    ASSERT(catchClause_ && finalizer_);
++    ASSERT(catch_clause_ && finalizer_);
+ 
+     compiler::TryContext tryCtx(pg, this);
+     const auto &labelSet = tryCtx.LabelSet();
+@@ -89,7 +89,7 @@ void TryStatement::CompileTryCatchFinally(compiler::PandaGen *pg) const
+         pg->Branch(this, innerLabelSet.CatchEnd());
+ 
+         pg->SetLabel(this, innerLabelSet.CatchBegin());
+-        catchClause_->Compile(pg);
++        catch_clause_->Compile(pg);
+         pg->SetLabel(this, innerLabelSet.CatchEnd());
+     }
+     pg->SetLabel(this, labelSet.TryEnd());
+@@ -99,7 +99,7 @@ void TryStatement::CompileTryCatchFinally(compiler::PandaGen *pg) const
+ 
+ void TryStatement::CompileTryFinally(compiler::PandaGen *pg) const
+ {
+-    ASSERT(!catchClause_ && finalizer_);
++    ASSERT(!catch_clause_ && finalizer_);
+ 
+     compiler::TryContext tryCtx(pg, this);
+     const auto &labelSet = tryCtx.LabelSet();
+@@ -126,7 +126,7 @@ void TryStatement::CompileTryFinally(compiler::PandaGen *pg) const
+ 
+ void TryStatement::CompileTryCatch(compiler::PandaGen *pg) const
+ {
+-    ASSERT(catchClause_ && !finalizer_);
++    ASSERT(catch_clause_ && !finalizer_);
+ 
+     compiler::TryContext tryCtx(pg, this);
+     const auto &labelSet = tryCtx.LabelSet();
+@@ -138,14 +138,14 @@ void TryStatement::CompileTryCatch(compiler::PandaGen *pg) const
+     pg->Branch(this, labelSet.CatchEnd());
+ 
+     pg->SetLabel(this, labelSet.CatchBegin());
+-    catchClause_->Compile(pg);
++    catch_clause_->Compile(pg);
+     pg->SetLabel(this, labelSet.CatchEnd());
+ }
+ 
+ void TryStatement::Compile([[maybe_unused]] compiler::PandaGen *pg) const
+ {
+     if (finalizer_) {
+-        if (catchClause_) {
++        if (catch_clause_) {
+             CompileTryCatchFinally(pg);
+         } else {
+             CompileTryFinally(pg);
+@@ -159,8 +159,8 @@ checker::Type *TryStatement::Check([[maybe_unused]] checker::Checker *checker) c
+ {
+     block_->Check(checker);
+ 
+-    if (catchClause_) {
+-        catchClause_->Check(checker);
++    if (catch_clause_) {
++        catch_clause_->Check(checker);
+     }
+ 
+     if (finalizer_) {
+diff --git a/ir/statements/tryStatement.h b/ir/statements/tryStatement.h
+index c824b99..f41122e 100644
+--- a/ir/statements/tryStatement.h
++++ b/ir/statements/tryStatement.h
+@@ -37,7 +37,7 @@ class CatchClause;
+ class TryStatement : public Statement {
+ public:
+     explicit TryStatement(BlockStatement *block, CatchClause *catchClause, BlockStatement *finalizer)
+-        : Statement(AstNodeType::TRY_STATEMENT), block_(block), catchClause_(catchClause), finalizer_(finalizer)
++        : Statement(AstNodeType::TRY_STATEMENT), block_(block), catch_clause_(catchClause), finalizer_(finalizer)
+     {
+     }
+ 
+@@ -53,7 +53,7 @@ public:
+ 
+     CatchClause *GetCatchClause() const
+     {
+-        return catchClause_;
++        return catch_clause_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -69,7 +69,7 @@ private:
+                         const compiler::TryLabelSet &labelSet) const;
+ 
+     BlockStatement *block_;
+-    CatchClause *catchClause_;
++    CatchClause *catch_clause_;
+     BlockStatement *finalizer_;
+ };
+ 
+diff --git a/ir/statements/variableDeclaration.cpp b/ir/statements/variableDeclaration.cpp
+index 0e987e9..b9711cd 100644
+--- a/ir/statements/variableDeclaration.cpp
++++ b/ir/statements/variableDeclaration.cpp
+@@ -94,8 +94,8 @@ static TypeAnnotationDestructuringType GetTypeAnnotationNodeAndDestructuringType
+ 
+     ASSERT(decl->Id()->IsIdentifier());
+     binder::ScopeFindResult result = checker->Scope()->Find(decl->Id()->AsIdentifier()->Name());
+-    ASSERT(result.variable);
+-    return {result.variable, decl->Id()->AsIdentifier()->TypeAnnotation(),
++    ASSERT(result.variable_);
++    return {result.variable_, decl->Id()->AsIdentifier()->TypeAnnotation(),
+             checker::DestructuringType::NO_DESTRUCTURING};
+ }
+ 
+diff --git a/ir/ts/tsArrayType.cpp b/ir/ts/tsArrayType.cpp
+index 85fb329..49a7d28 100644
+--- a/ir/ts/tsArrayType.cpp
++++ b/ir/ts/tsArrayType.cpp
+@@ -21,12 +21,12 @@ namespace panda::es2panda::ir {
+ 
+ void TSArrayType::Iterate(const NodeTraverser &cb) const
+ {
+-    cb(elementType_);
++    cb(element_type_);
+ }
+ 
+ void TSArrayType::Dump(ir::AstDumper *dumper) const
+ {
+-    dumper->Add({{"type", "TSArrayType"}, {"elementType", elementType_}});
++    dumper->Add({{"type", "TSArrayType"}, {"elementType", element_type_}});
+ }
+ 
+ void TSArrayType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsArrayType.h b/ir/ts/tsArrayType.h
+index 3e550e6..f18a096 100644
+--- a/ir/ts/tsArrayType.h
++++ b/ir/ts/tsArrayType.h
+@@ -31,11 +31,13 @@ namespace panda::es2panda::ir {
+ 
+ class TSArrayType : public Expression {
+ public:
+-    explicit TSArrayType(Expression *elementType) : Expression(AstNodeType::TS_ARRAY_TYPE), elementType_(elementType) {}
++    explicit TSArrayType(Expression *elementType) : Expression(AstNodeType::TS_ARRAY_TYPE), element_type_(elementType)
++    {
++    }
+ 
+     const Expression *ElementType() const
+     {
+-        return elementType_;
++        return element_type_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -44,7 +46,7 @@ public:
+     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+ 
+ private:
+-    Expression *elementType_;
++    Expression *element_type_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsAsExpression.cpp b/ir/ts/tsAsExpression.cpp
+index 1e32fa7..273ee8c 100644
+--- a/ir/ts/tsAsExpression.cpp
++++ b/ir/ts/tsAsExpression.cpp
+@@ -27,12 +27,12 @@ namespace panda::es2panda::ir {
+ void TSAsExpression::Iterate(const NodeTraverser &cb) const
+ {
+     cb(expression_);
+-    cb(typeAnnotation_);
++    cb(type_annotation_);
+ }
+ 
+ void TSAsExpression::Dump(ir::AstDumper *dumper) const
+ {
+-    dumper->Add({{"type", "TSAsExpression"}, {"expression", expression_}, {"typeAnnotation", typeAnnotation_}});
++    dumper->Add({{"type", "TSAsExpression"}, {"expression", expression_}, {"typeAnnotation", type_annotation_}});
+ }
+ 
+ void TSAsExpression::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+@@ -63,8 +63,8 @@ static bool IsValidConstAssertionArgument(checker::Checker *checker, const ir::A
+             if (memberExpr->Object()->IsIdentifier()) {
+                 binder::ScopeFindResult result = checker->Scope()->Find(memberExpr->Object()->AsIdentifier()->Name());
+                 constexpr auto enumLiteralType = checker::EnumLiteralType::EnumLiteralTypeKind::LITERAL;
+-                if (result.variable && result.variable->TsType()->HasTypeFlag(checker::TypeFlag::ENUM_LITERAL) &&
+-                    result.variable->TsType()->AsEnumLiteralType()->Kind() == enumLiteralType) {
++                if (result.variable_ && result.variable_->TsType()->HasTypeFlag(checker::TypeFlag::ENUM_LITERAL) &&
++                    result.variable_->TsType()->AsEnumLiteralType()->Kind() == enumLiteralType) {
+                     return true;
+                 }
+             }
+@@ -80,7 +80,7 @@ checker::Type *TSAsExpression::Check([[maybe_unused]] checker::Checker *checker)
+     // TODO(aszilagyi): params is_const_, is_const_
+     checker::Type *exprType = expression_->Check(checker);
+ 
+-    if (isConst_) {
++    if (is_const_) {
+         if (!IsValidConstAssertionArgument(checker, expression_)) {
+             checker->ThrowTypeError(
+                 "A 'const' assertions can only be applied to references to enum members, or string, number, "
+@@ -96,7 +96,7 @@ checker::Type *TSAsExpression::Check([[maybe_unused]] checker::Checker *checker)
+         exprType->AsObjectType()->RemoveObjectFlag(checker::ObjectType::ObjectFlags::CHECK_EXCESS_PROPS);
+     }
+ 
+-    checker::Type *targetType = typeAnnotation_->Check(checker);
++    checker::Type *targetType = type_annotation_->Check(checker);
+ 
+     checker->IsTypeComparableTo(
+         targetType, exprType,
+diff --git a/ir/ts/tsAsExpression.h b/ir/ts/tsAsExpression.h
+index 43b5c8d..20c4872 100644
+--- a/ir/ts/tsAsExpression.h
++++ b/ir/ts/tsAsExpression.h
+@@ -35,8 +35,8 @@ public:
+     explicit TSAsExpression(Expression *expression, Expression *typeAnnotation, bool isConst)
+         : Expression(AstNodeType::TS_AS_EXPRESSION),
+           expression_(expression),
+-          typeAnnotation_(typeAnnotation),
+-          isConst_(isConst)
++          type_annotation_(typeAnnotation),
++          is_const_(isConst)
+     {
+     }
+ 
+@@ -47,12 +47,12 @@ public:
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     bool IsConst() const
+     {
+-        return isConst_;
++        return is_const_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -62,8 +62,8 @@ public:
+ 
+ private:
+     Expression *expression_;
+-    Expression *typeAnnotation_;
+-    bool isConst_;
++    Expression *type_annotation_;
++    bool is_const_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsClassImplements.cpp b/ir/ts/tsClassImplements.cpp
+index c122178..866dc11 100644
+--- a/ir/ts/tsClassImplements.cpp
++++ b/ir/ts/tsClassImplements.cpp
+@@ -25,8 +25,8 @@ void TSClassImplements::Iterate(const NodeTraverser &cb) const
+ {
+     cb(expression_);
+ 
+-    if (typeParameters_) {
+-        cb(typeParameters_);
++    if (type_parameters_) {
++        cb(type_parameters_);
+     }
+ }
+ 
+@@ -34,7 +34,7 @@ void TSClassImplements::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TSClassImplements"},
+                  {"expression", expression_},
+-                 {"typeParameters", AstDumper::Optional(typeParameters_)}});
++                 {"typeParameters", AstDumper::Optional(type_parameters_)}});
+ }
+ 
+ void TSClassImplements::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsClassImplements.h b/ir/ts/tsClassImplements.h
+index 3926e09..e4d2a65 100644
+--- a/ir/ts/tsClassImplements.h
++++ b/ir/ts/tsClassImplements.h
+@@ -34,7 +34,7 @@ class TSTypeParameterInstantiation;
+ class TSClassImplements : public Expression {
+ public:
+     explicit TSClassImplements(Expression *expression, TSTypeParameterInstantiation *typeParameters)
+-        : Expression(AstNodeType::TS_AS_EXPRESSION), expression_(expression), typeParameters_(typeParameters)
++        : Expression(AstNodeType::TS_AS_EXPRESSION), expression_(expression), type_parameters_(typeParameters)
+     {
+     }
+ 
+@@ -45,7 +45,7 @@ public:
+ 
+     const TSTypeParameterInstantiation *TypeParameters() const
+     {
+-        return typeParameters_;
++        return type_parameters_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -55,7 +55,7 @@ public:
+ 
+ private:
+     Expression *expression_;
+-    TSTypeParameterInstantiation *typeParameters_;
++    TSTypeParameterInstantiation *type_parameters_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsConditionalType.cpp b/ir/ts/tsConditionalType.cpp
+index cbf616e..31e4e26 100644
+--- a/ir/ts/tsConditionalType.cpp
++++ b/ir/ts/tsConditionalType.cpp
+@@ -21,19 +21,19 @@ namespace panda::es2panda::ir {
+ 
+ void TSConditionalType::Iterate(const NodeTraverser &cb) const
+ {
+-    cb(checkType_);
+-    cb(extendsType_);
+-    cb(trueType_);
+-    cb(falseType_);
++    cb(check_type_);
++    cb(extends_type_);
++    cb(true_type_);
++    cb(false_type_);
+ }
+ 
+ void TSConditionalType::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TSConditionalType"},
+-                 {"checkType", checkType_},
+-                 {"extendsType", extendsType_},
+-                 {"trueType", trueType_},
+-                 {"falseType", falseType_}});
++                 {"checkType", check_type_},
++                 {"extendsType", extends_type_},
++                 {"trueType", true_type_},
++                 {"falseType", false_type_}});
+ }
+ 
+ void TSConditionalType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsConditionalType.h b/ir/ts/tsConditionalType.h
+index 1a01ad7..97efd24 100644
+--- a/ir/ts/tsConditionalType.h
++++ b/ir/ts/tsConditionalType.h
+@@ -34,31 +34,31 @@ public:
+     explicit TSConditionalType(Expression *checkType, Expression *extendsType, Expression *trueType,
+                                Expression *falseType)
+         : Expression(AstNodeType::TS_CONDITIONAL_TYPE),
+-          checkType_(checkType),
+-          extendsType_(extendsType),
+-          trueType_(trueType),
+-          falseType_(falseType)
++          check_type_(checkType),
++          extends_type_(extendsType),
++          true_type_(trueType),
++          false_type_(falseType)
+     {
+     }
+ 
+     const Expression *CheckType() const
+     {
+-        return checkType_;
++        return check_type_;
+     }
+ 
+     const Expression *ExtendsType() const
+     {
+-        return extendsType_;
++        return extends_type_;
+     }
+ 
+     const Expression *TrueType() const
+     {
+-        return trueType_;
++        return true_type_;
+     }
+ 
+     const Expression *FalseType() const
+     {
+-        return falseType_;
++        return false_type_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -67,10 +67,10 @@ public:
+     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+ 
+ private:
+-    Expression *checkType_;
+-    Expression *extendsType_;
+-    Expression *trueType_;
+-    Expression *falseType_;
++    Expression *check_type_;
++    Expression *extends_type_;
++    Expression *true_type_;
++    Expression *false_type_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsConstructorType.cpp b/ir/ts/tsConstructorType.cpp
+index 61d9544..3ddbc39 100644
+--- a/ir/ts/tsConstructorType.cpp
++++ b/ir/ts/tsConstructorType.cpp
+@@ -26,23 +26,23 @@ namespace panda::es2panda::ir {
+ 
+ void TSConstructorType::Iterate(const NodeTraverser &cb) const
+ {
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+     for (auto *it : params_) {
+         cb(it);
+     }
+ 
+-    cb(returnType_);
++    cb(return_type_);
+ }
+ 
+ void TSConstructorType::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TSConstructorType"},
+                  {"params", params_},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)},
+-                 {"returnType", returnType_},
++                 {"typeParameters", AstDumper::Optional(type_params_)},
++                 {"returnType", return_type_},
+                  {"abstract", AstDumper::Optional(abstract_)}});
+ }
+ 
+@@ -54,7 +54,7 @@ checker::Type *TSConstructorType::Check(checker::Checker *checker) const
+ 
+     auto *signatureInfo = checker->Allocator()->New<checker::SignatureInfo>();
+     checker->CheckFunctionParameterDeclaration(params_, signatureInfo);
+-    checker::Type *returnType = returnType_->Check(checker);
++    checker::Type *returnType = return_type_->Check(checker);
+     auto *constructSignature = checker->Allocator()->New<checker::Signature>(signatureInfo, returnType);
+ 
+     return checker->CreateConstructorTypeWithSignature(constructSignature);
+diff --git a/ir/ts/tsConstructorType.h b/ir/ts/tsConstructorType.h
+index fcb3b70..652cd70 100644
+--- a/ir/ts/tsConstructorType.h
++++ b/ir/ts/tsConstructorType.h
+@@ -42,8 +42,8 @@ public:
+         : Expression(AstNodeType::TS_CONSTRUCTOR_TYPE),
+           scope_(scope),
+           params_(std::move(params)),
+-          typeParams_(typeParams),
+-          returnType_(returnType),
++          type_params_(typeParams),
++          return_type_(returnType),
+           abstract_(abstract)
+     {
+     }
+@@ -55,7 +55,7 @@ public:
+ 
+     const TSTypeParameterDeclaration *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     const ArenaVector<Expression *> &Params() const
+@@ -65,7 +65,7 @@ public:
+ 
+     const Expression *ReturnType() const
+     {
+-        return returnType_;
++        return return_type_;
+     }
+ 
+     bool Abstract() const
+@@ -81,8 +81,8 @@ public:
+ private:
+     binder::Scope *scope_;
+     ArenaVector<Expression *> params_;
+-    TSTypeParameterDeclaration *typeParams_;
+-    Expression *returnType_;
++    TSTypeParameterDeclaration *type_params_;
++    Expression *return_type_;
+     bool abstract_;
+ };
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsEnumDeclaration.cpp b/ir/ts/tsEnumDeclaration.cpp
+index d92e673..041b1c4 100644
+--- a/ir/ts/tsEnumDeclaration.cpp
++++ b/ir/ts/tsEnumDeclaration.cpp
+@@ -41,7 +41,7 @@ void TSEnumDeclaration::Iterate(const NodeTraverser &cb) const
+ 
+ void TSEnumDeclaration::Dump(ir::AstDumper *dumper) const
+ {
+-    dumper->Add({{"type", "TSEnumDeclaration"}, {"id", key_}, {"members", members_}, {"const", isConst_}});
++    dumper->Add({{"type", "TSEnumDeclaration"}, {"id", key_}, {"members", members_}, {"const", is_const_}});
+ }
+ 
+ void TSEnumDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+@@ -390,7 +390,7 @@ checker::Type *TSEnumDeclaration::Check([[maybe_unused]] checker::Checker *check
+ 
+     if (!enumVar->TsType()) {
+         checker::ScopeContext scopeCtx(checker, scope_);
+-        checker::Type *enumType = InferType(checker, isConst_);
++        checker::Type *enumType = InferType(checker, is_const_);
+         enumType->SetVariable(enumVar);
+         enumVar->SetTsType(enumType);
+     }
+diff --git a/ir/ts/tsEnumDeclaration.h b/ir/ts/tsEnumDeclaration.h
+index 6baa9c7..59135a9 100644
+--- a/ir/ts/tsEnumDeclaration.h
++++ b/ir/ts/tsEnumDeclaration.h
+@@ -46,7 +46,7 @@ public:
+           scope_(scope),
+           key_(key),
+           members_(std::move(members)),
+-          isConst_(isConst)
++          is_const_(isConst)
+     {
+     }
+ 
+@@ -67,7 +67,7 @@ public:
+ 
+     bool IsConst() const
+     {
+-        return isConst_;
++        return is_const_;
+     }
+ 
+     static binder::EnumMemberResult EvaluateEnumMember(checker::Checker *checker, binder::EnumVariable *enumVar,
+@@ -83,7 +83,7 @@ private:
+     binder::LocalScope *scope_;
+     Identifier *key_;
+     ArenaVector<TSEnumMember *> members_;
+-    bool isConst_;
++    bool is_const_;
+ };
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsFunctionType.cpp b/ir/ts/tsFunctionType.cpp
+index 43e12a3..9e21e82 100644
+--- a/ir/ts/tsFunctionType.cpp
++++ b/ir/ts/tsFunctionType.cpp
+@@ -26,23 +26,23 @@ namespace panda::es2panda::ir {
+ 
+ void TSFunctionType::Iterate(const NodeTraverser &cb) const
+ {
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+     for (auto *it : params_) {
+         cb(it);
+     }
+ 
+-    cb(returnType_);
++    cb(return_type_);
+ }
+ 
+ void TSFunctionType::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TSFunctionType"},
+                  {"params", params_},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)},
+-                 {"returnType", returnType_}});
++                 {"typeParameters", AstDumper::Optional(type_params_)},
++                 {"returnType", return_type_}});
+ }
+ 
+ void TSFunctionType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+@@ -53,7 +53,7 @@ checker::Type *TSFunctionType::Check(checker::Checker *checker) const
+ 
+     auto *signatureInfo = checker->Allocator()->New<checker::SignatureInfo>();
+     checker->CheckFunctionParameterDeclaration(params_, signatureInfo);
+-    checker::Type *returnType = returnType_->Check(checker);
++    checker::Type *returnType = return_type_->Check(checker);
+     auto *callSignature = checker->Allocator()->New<checker::Signature>(signatureInfo, returnType);
+ 
+     return checker->CreateFunctionTypeWithSignature(callSignature);
+diff --git a/ir/ts/tsFunctionType.h b/ir/ts/tsFunctionType.h
+index 49f9d9f..e882e4f 100644
+--- a/ir/ts/tsFunctionType.h
++++ b/ir/ts/tsFunctionType.h
+@@ -42,8 +42,8 @@ public:
+         : Expression(AstNodeType::TS_FUNCTION_TYPE),
+           scope_(scope),
+           params_(std::move(params)),
+-          typeParams_(typeParams),
+-          returnType_(returnType)
++          type_params_(typeParams),
++          return_type_(returnType)
+     {
+     }
+ 
+@@ -54,7 +54,7 @@ public:
+ 
+     const TSTypeParameterDeclaration *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     const ArenaVector<Expression *> &Params() const
+@@ -64,7 +64,7 @@ public:
+ 
+     const Expression *ReturnType() const
+     {
+-        return returnType_;
++        return return_type_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -75,8 +75,8 @@ public:
+ private:
+     binder::Scope *scope_;
+     ArenaVector<Expression *> params_;
+-    TSTypeParameterDeclaration *typeParams_;
+-    Expression *returnType_;
++    TSTypeParameterDeclaration *type_params_;
++    Expression *return_type_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsImportEqualsDeclaration.cpp b/ir/ts/tsImportEqualsDeclaration.cpp
+index 89b612b..e0b74f2 100644
+--- a/ir/ts/tsImportEqualsDeclaration.cpp
++++ b/ir/ts/tsImportEqualsDeclaration.cpp
+@@ -24,15 +24,15 @@ namespace panda::es2panda::ir {
+ void TSImportEqualsDeclaration::Iterate(const NodeTraverser &cb) const
+ {
+     cb(id_);
+-    cb(moduleReference_);
++    cb(module_reference_);
+ }
+ 
+ void TSImportEqualsDeclaration::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TSImportEqualsDeclaration"},
+                  {"id", id_},
+-                 {"moduleReference", moduleReference_},
+-                 {"isExport", isExport_}});
++                 {"moduleReference", module_reference_},
++                 {"isExport", is_export_}});
+ }
+ 
+ void TSImportEqualsDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsImportEqualsDeclaration.h b/ir/ts/tsImportEqualsDeclaration.h
+index 8bcd9e6..5a61571 100644
+--- a/ir/ts/tsImportEqualsDeclaration.h
++++ b/ir/ts/tsImportEqualsDeclaration.h
+@@ -36,8 +36,8 @@ public:
+     explicit TSImportEqualsDeclaration(Identifier *id, Expression *moduleReference, bool isExport)
+         : Statement(AstNodeType::TS_IMPORT_EQUALS_DECLARATION),
+           id_(id),
+-          moduleReference_(moduleReference),
+-          isExport_(isExport)
++          module_reference_(moduleReference),
++          is_export_(isExport)
+     {
+     }
+ 
+@@ -48,12 +48,12 @@ public:
+ 
+     const Expression *ModuleReference() const
+     {
+-        return moduleReference_;
++        return module_reference_;
+     }
+ 
+     bool IsExport() const
+     {
+-        return isExport_;
++        return is_export_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -63,8 +63,8 @@ public:
+ 
+ private:
+     Identifier *id_;
+-    Expression *moduleReference_;
+-    bool isExport_;
++    Expression *module_reference_;
++    bool is_export_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsImportType.cpp b/ir/ts/tsImportType.cpp
+index 06b65b3..290d3d8 100644
+--- a/ir/ts/tsImportType.cpp
++++ b/ir/ts/tsImportType.cpp
+@@ -25,8 +25,8 @@ void TSImportType::Iterate(const NodeTraverser &cb) const
+ {
+     cb(param_);
+ 
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+     if (qualifier_) {
+@@ -39,8 +39,8 @@ void TSImportType::Dump(ir::AstDumper *dumper) const
+     dumper->Add({{"type", "TSImportType"},
+                  {"parameter", param_},
+                  {"qualifier", AstDumper::Optional(qualifier_)},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)},
+-                 {"isTypeOf", isTypeof_}});
++                 {"typeParameters", AstDumper::Optional(type_params_)},
++                 {"isTypeOf", is_typeof_}});
+ }
+ 
+ void TSImportType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsImportType.h b/ir/ts/tsImportType.h
+index 08a6c67..5e8d744 100644
+--- a/ir/ts/tsImportType.h
++++ b/ir/ts/tsImportType.h
+@@ -37,9 +37,9 @@ public:
+                           bool isTypeof)
+         : Expression(AstNodeType::TS_IMPORT_TYPE),
+           param_(param),
+-          typeParams_(typeParams),
++          type_params_(typeParams),
+           qualifier_(qualifier),
+-          isTypeof_(isTypeof)
++          is_typeof_(isTypeof)
+     {
+     }
+ 
+@@ -50,7 +50,7 @@ public:
+ 
+     const TSTypeParameterInstantiation *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     const Expression *Qualifier() const
+@@ -60,7 +60,7 @@ public:
+ 
+     bool IsTypeof() const
+     {
+-        return isTypeof_;
++        return is_typeof_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -70,9 +70,9 @@ public:
+ 
+ private:
+     Expression *param_;
+-    TSTypeParameterInstantiation *typeParams_;
++    TSTypeParameterInstantiation *type_params_;
+     Expression *qualifier_;
+-    bool isTypeof_;
++    bool is_typeof_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsIndexSignature.cpp b/ir/ts/tsIndexSignature.cpp
+index 67c106b..7fdda32 100644
+--- a/ir/ts/tsIndexSignature.cpp
++++ b/ir/ts/tsIndexSignature.cpp
+@@ -29,14 +29,14 @@ TSIndexSignature::TSIndexSignatureKind TSIndexSignature::Kind() const
+ void TSIndexSignature::Iterate(const NodeTraverser &cb) const
+ {
+     cb(param_);
+-    cb(typeAnnotation_);
++    cb(type_annotation_);
+ }
+ 
+ void TSIndexSignature::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TSIndexSignature"},
+                  {"parameters", param_},
+-                 {"typeAnnotation", typeAnnotation_},
++                 {"typeAnnotation", type_annotation_},
+                  {"readonly", readonly_}});
+ }
+ 
+diff --git a/ir/ts/tsIndexSignature.h b/ir/ts/tsIndexSignature.h
+index 334b042..0dbac32 100644
+--- a/ir/ts/tsIndexSignature.h
++++ b/ir/ts/tsIndexSignature.h
+@@ -36,7 +36,7 @@ public:
+     explicit TSIndexSignature(Expression *param, Expression *typeAnnotation, bool readonly)
+         : Expression(AstNodeType::TS_INDEX_SIGNATURE),
+           param_(param),
+-          typeAnnotation_(typeAnnotation),
++          type_annotation_(typeAnnotation),
+           readonly_(readonly)
+     {
+     }
+@@ -48,7 +48,7 @@ public:
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     bool Readonly() const
+@@ -65,7 +65,7 @@ public:
+ 
+ private:
+     Expression *param_;
+-    Expression *typeAnnotation_;
++    Expression *type_annotation_;
+     bool readonly_;
+ };
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsIndexedAccessType.cpp b/ir/ts/tsIndexedAccessType.cpp
+index 2e55dce..4859c3c 100644
+--- a/ir/ts/tsIndexedAccessType.cpp
++++ b/ir/ts/tsIndexedAccessType.cpp
+@@ -22,21 +22,21 @@ namespace panda::es2panda::ir {
+ 
+ void TSIndexedAccessType::Iterate(const NodeTraverser &cb) const
+ {
+-    cb(objectType_);
+-    cb(indexType_);
++    cb(object_type_);
++    cb(index_type_);
+ }
+ 
+ void TSIndexedAccessType::Dump(ir::AstDumper *dumper) const
+ {
+-    dumper->Add({{"type", "TSIndexedAccessType"}, {"objectType", objectType_}, {"indexType", indexType_}});
++    dumper->Add({{"type", "TSIndexedAccessType"}, {"objectType", object_type_}, {"indexType", index_type_}});
+ }
+ 
+ void TSIndexedAccessType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+ 
+ checker::Type *TSIndexedAccessType::Check([[maybe_unused]] checker::Checker *checker) const
+ {
+-    checker::Type *baseType = objectType_->Check(checker);
+-    checker::Type *propType = checker->ResolveBaseProp(baseType, indexType_, false, Start());
++    checker::Type *baseType = object_type_->Check(checker);
++    checker::Type *propType = checker->ResolveBaseProp(baseType, index_type_, false, Start());
+ 
+     return propType;
+ }
+diff --git a/ir/ts/tsIndexedAccessType.h b/ir/ts/tsIndexedAccessType.h
+index 20ca95f..5568a8e 100644
+--- a/ir/ts/tsIndexedAccessType.h
++++ b/ir/ts/tsIndexedAccessType.h
+@@ -32,18 +32,18 @@ namespace panda::es2panda::ir {
+ class TSIndexedAccessType : public Expression {
+ public:
+     explicit TSIndexedAccessType(Expression *objectType, Expression *indexType)
+-        : Expression(AstNodeType::TS_INDEXED_ACCESS_TYPE), objectType_(objectType), indexType_(indexType)
++        : Expression(AstNodeType::TS_INDEXED_ACCESS_TYPE), object_type_(objectType), index_type_(indexType)
+     {
+     }
+ 
+     const Expression *ObjectType() const
+     {
+-        return objectType_;
++        return object_type_;
+     }
+ 
+     const Expression *IndexType() const
+     {
+-        return indexType_;
++        return index_type_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -52,8 +52,8 @@ public:
+     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+ 
+ private:
+-    Expression *objectType_;
+-    Expression *indexType_;
++    Expression *object_type_;
++    Expression *index_type_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsInferType.cpp b/ir/ts/tsInferType.cpp
+index e549496..b8b5afc 100644
+--- a/ir/ts/tsInferType.cpp
++++ b/ir/ts/tsInferType.cpp
+@@ -22,12 +22,12 @@ namespace panda::es2panda::ir {
+ 
+ void TSInferType::Iterate(const NodeTraverser &cb) const
+ {
+-    cb(typeParam_);
++    cb(type_param_);
+ }
+ 
+ void TSInferType::Dump(ir::AstDumper *dumper) const
+ {
+-    dumper->Add({{"type", "TSInferType"}, {"typeParameter", typeParam_}});
++    dumper->Add({{"type", "TSInferType"}, {"typeParameter", type_param_}});
+ }
+ 
+ void TSInferType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsInferType.h b/ir/ts/tsInferType.h
+index a454774..22c46b4 100644
+--- a/ir/ts/tsInferType.h
++++ b/ir/ts/tsInferType.h
+@@ -33,11 +33,11 @@ class TSTypeParameter;
+ 
+ class TSInferType : public Expression {
+ public:
+-    explicit TSInferType(TSTypeParameter *typeParam) : Expression(AstNodeType::TS_INFER_TYPE), typeParam_(typeParam) {}
++    explicit TSInferType(TSTypeParameter *typeParam) : Expression(AstNodeType::TS_INFER_TYPE), type_param_(typeParam) {}
+ 
+     const TSTypeParameter *TypeParam() const
+     {
+-        return typeParam_;
++        return type_param_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -46,7 +46,7 @@ public:
+     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+ 
+ private:
+-    TSTypeParameter *typeParam_;
++    TSTypeParameter *type_param_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsInterfaceDeclaration.cpp b/ir/ts/tsInterfaceDeclaration.cpp
+index 4974d72..3c0587a 100644
+--- a/ir/ts/tsInterfaceDeclaration.cpp
++++ b/ir/ts/tsInterfaceDeclaration.cpp
+@@ -32,8 +32,8 @@ void TSInterfaceDeclaration::Iterate(const NodeTraverser &cb) const
+ {
+     cb(id_);
+ 
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+     cb(body_);
+@@ -49,7 +49,7 @@ void TSInterfaceDeclaration::Dump(ir::AstDumper *dumper) const
+                  {"body", body_},
+                  {"id", id_},
+                  {"extends", extends_},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)}});
++                 {"typeParameters", AstDumper::Optional(type_params_)}});
+ }
+ 
+ void TSInterfaceDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsInterfaceDeclaration.h b/ir/ts/tsInterfaceDeclaration.h
+index e613ae1..c890323 100644
+--- a/ir/ts/tsInterfaceDeclaration.h
++++ b/ir/ts/tsInterfaceDeclaration.h
+@@ -46,7 +46,7 @@ public:
+         : Statement(AstNodeType::TS_INTERFACE_DECLARATION),
+           scope_(scope),
+           id_(id),
+-          typeParams_(typeParams),
++          type_params_(typeParams),
+           body_(body),
+           extends_(std::move(extends))
+     {
+@@ -69,7 +69,7 @@ public:
+ 
+     const TSTypeParameterDeclaration *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     const ArenaVector<TSInterfaceHeritage *> &Extends() const
+@@ -86,7 +86,7 @@ public:
+ private:
+     binder::LocalScope *scope_;
+     Identifier *id_;
+-    TSTypeParameterDeclaration *typeParams_;
++    TSTypeParameterDeclaration *type_params_;
+     TSInterfaceBody *body_;
+     ArenaVector<TSInterfaceHeritage *> extends_;
+ };
+diff --git a/ir/ts/tsInterfaceHeritage.cpp b/ir/ts/tsInterfaceHeritage.cpp
+index 79d8e44..6daafa6 100644
+--- a/ir/ts/tsInterfaceHeritage.cpp
++++ b/ir/ts/tsInterfaceHeritage.cpp
+@@ -28,15 +28,16 @@ void TSInterfaceHeritage::Iterate(const NodeTraverser &cb) const
+ {
+     cb(expr_);
+ 
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ }
+ 
+ void TSInterfaceHeritage::Dump(ir::AstDumper *dumper) const
+ {
+-    dumper->Add(
+-        {{"type", "TSInterfaceHeritage"}, {"expression", expr_}, {"typeParameters", AstDumper::Optional(typeParams_)}});
++    dumper->Add({{"type", "TSInterfaceHeritage"},
++                 {"expression", expr_},
++                 {"typeParameters", AstDumper::Optional(type_params_)}});
+ }
+ 
+ void TSInterfaceHeritage::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsInterfaceHeritage.h b/ir/ts/tsInterfaceHeritage.h
+index fb2a86d..a314b26 100644
+--- a/ir/ts/tsInterfaceHeritage.h
++++ b/ir/ts/tsInterfaceHeritage.h
+@@ -35,7 +35,7 @@ class TSTypeParameterInstantiation;
+ class TSInterfaceHeritage : public Expression {
+ public:
+     explicit TSInterfaceHeritage(Expression *expr, TSTypeParameterInstantiation *typeParams)
+-        : Expression(AstNodeType::TS_INTERFACE_HERITAGE), expr_(expr), typeParams_(typeParams)
++        : Expression(AstNodeType::TS_INTERFACE_HERITAGE), expr_(expr), type_params_(typeParams)
+     {
+     }
+ 
+@@ -46,7 +46,7 @@ public:
+ 
+     const TSTypeParameterInstantiation *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -56,7 +56,7 @@ public:
+ 
+ private:
+     Expression *expr_;
+-    TSTypeParameterInstantiation *typeParams_;
++    TSTypeParameterInstantiation *type_params_;
+ };
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsMappedType.cpp b/ir/ts/tsMappedType.cpp
+index 9fd99c5..0f48aac 100644
+--- a/ir/ts/tsMappedType.cpp
++++ b/ir/ts/tsMappedType.cpp
+@@ -22,17 +22,17 @@ namespace panda::es2panda::ir {
+ 
+ void TSMappedType::Iterate(const NodeTraverser &cb) const
+ {
+-    cb(typeParameter_);
+-    if (typeAnnotation_) {
+-        cb(typeAnnotation_);
++    cb(type_parameter_);
++    if (type_annotation_) {
++        cb(type_annotation_);
+     }
+ }
+ 
+ void TSMappedType::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TSMappedType"},
+-                 {"typeParameter", typeParameter_},
+-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)},
++                 {"typeParameter", type_parameter_},
++                 {"typeAnnotation", AstDumper::Optional(type_annotation_)},
+                  {"readonly", readonly_ == MappedOption::NO_OPTS ? AstDumper::Optional(false)
+                               : readonly_ == MappedOption::PLUS  ? AstDumper::Optional("+")
+                                                                  : AstDumper::Optional("-")},
+diff --git a/ir/ts/tsMappedType.h b/ir/ts/tsMappedType.h
+index 6fe4403..29c9ce9 100644
+--- a/ir/ts/tsMappedType.h
++++ b/ir/ts/tsMappedType.h
+@@ -35,8 +35,8 @@ public:
+     explicit TSMappedType(TSTypeParameter *typeParameter, Expression *typeAnnotation, MappedOption readonly,
+                           MappedOption optional)
+         : Expression(AstNodeType::TS_MAPPED_TYPE),
+-          typeParameter_(typeParameter),
+-          typeAnnotation_(typeAnnotation),
++          type_parameter_(typeParameter),
++          type_annotation_(typeAnnotation),
+           readonly_(readonly),
+           optional_(optional)
+     {
+@@ -44,12 +44,12 @@ public:
+ 
+     TSTypeParameter *TypeParameter()
+     {
+-        return typeParameter_;
++        return type_parameter_;
+     }
+ 
+     Expression *TypeAnnotation()
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     MappedOption Readonly()
+@@ -68,8 +68,8 @@ public:
+     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+ 
+ private:
+-    TSTypeParameter *typeParameter_;
+-    Expression *typeAnnotation_;
++    TSTypeParameter *type_parameter_;
++    Expression *type_annotation_;
+     MappedOption readonly_;
+     MappedOption optional_;
+ };
+diff --git a/ir/ts/tsMethodSignature.cpp b/ir/ts/tsMethodSignature.cpp
+index ee83c85..6da3998 100644
+--- a/ir/ts/tsMethodSignature.cpp
++++ b/ir/ts/tsMethodSignature.cpp
+@@ -26,16 +26,16 @@ void TSMethodSignature::Iterate(const NodeTraverser &cb) const
+ {
+     cb(key_);
+ 
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+     for (auto *it : params_) {
+         cb(it);
+     }
+ 
+-    if (returnTypeAnnotation_) {
+-        cb(returnTypeAnnotation_);
++    if (return_type_annotation_) {
++        cb(return_type_annotation_);
+     }
+ }
+ 
+@@ -46,8 +46,8 @@ void TSMethodSignature::Dump(ir::AstDumper *dumper) const
+                  {"optional", optional_},
+                  {"key", key_},
+                  {"params", params_},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)},
+-                 {"typeAnnotation", AstDumper::Optional(returnTypeAnnotation_)}});
++                 {"typeParameters", AstDumper::Optional(type_params_)},
++                 {"typeAnnotation", AstDumper::Optional(return_type_annotation_)}});
+ }
+ 
+ void TSMethodSignature::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsMethodSignature.h b/ir/ts/tsMethodSignature.h
+index 6f13eb0..3bbce77 100644
+--- a/ir/ts/tsMethodSignature.h
++++ b/ir/ts/tsMethodSignature.h
+@@ -43,9 +43,9 @@ public:
+         : Expression(AstNodeType::TS_METHOD_SIGNATURE),
+           scope_(scope),
+           key_(key),
+-          typeParams_(typeParams),
++          type_params_(typeParams),
+           params_(std::move(params)),
+-          returnTypeAnnotation_(returnTypeAnnotation),
++          return_type_annotation_(returnTypeAnnotation),
+           computed_(computed),
+           optional_(optional)
+     {
+@@ -63,7 +63,7 @@ public:
+ 
+     const TSTypeParameterDeclaration *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     const ArenaVector<Expression *> &Params() const
+@@ -73,7 +73,7 @@ public:
+ 
+     const Expression *ReturnTypeAnnotation() const
+     {
+-        return returnTypeAnnotation_;
++        return return_type_annotation_;
+     }
+ 
+     bool Computed() const
+@@ -94,9 +94,9 @@ public:
+ private:
+     binder::Scope *scope_;
+     Expression *key_;
+-    TSTypeParameterDeclaration *typeParams_;
++    TSTypeParameterDeclaration *type_params_;
+     ArenaVector<Expression *> params_;
+-    Expression *returnTypeAnnotation_;
++    Expression *return_type_annotation_;
+     bool computed_;
+     bool optional_;
+ };
+diff --git a/ir/ts/tsNamedTupleMember.cpp b/ir/ts/tsNamedTupleMember.cpp
+index 712e445..bb49deb 100644
+--- a/ir/ts/tsNamedTupleMember.cpp
++++ b/ir/ts/tsNamedTupleMember.cpp
+@@ -22,13 +22,13 @@ namespace panda::es2panda::ir {
+ void TSNamedTupleMember::Iterate(const NodeTraverser &cb) const
+ {
+     cb(label_);
+-    cb(elementType_);
++    cb(element_type_);
+ }
+ 
+ void TSNamedTupleMember::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TSNamedTupleMember"},
+-                 {"elementType", elementType_},
++                 {"elementType", element_type_},
+                  {"label", label_},
+                  {"optional", AstDumper::Optional(optional_)}});
+ }
+diff --git a/ir/ts/tsNamedTupleMember.h b/ir/ts/tsNamedTupleMember.h
+index 9c900a3..45716ab 100644
+--- a/ir/ts/tsNamedTupleMember.h
++++ b/ir/ts/tsNamedTupleMember.h
+@@ -32,7 +32,7 @@ namespace panda::es2panda::ir {
+ class TSNamedTupleMember : public Expression {
+ public:
+     explicit TSNamedTupleMember(Expression *label, Expression *elementType, bool optional)
+-        : Expression(AstNodeType::TS_NAMED_TUPLE_MEMBER), label_(label), elementType_(elementType), optional_(optional)
++        : Expression(AstNodeType::TS_NAMED_TUPLE_MEMBER), label_(label), element_type_(elementType), optional_(optional)
+     {
+     }
+ 
+@@ -43,7 +43,7 @@ public:
+ 
+     const Expression *ElementType() const
+     {
+-        return elementType_;
++        return element_type_;
+     }
+ 
+     bool IsOptional() const
+@@ -58,7 +58,7 @@ public:
+ 
+ private:
+     Expression *label_;
+-    Expression *elementType_;
++    Expression *element_type_;
+     bool optional_;
+ };
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsPrivateIdentifier.cpp b/ir/ts/tsPrivateIdentifier.cpp
+index e510353..c3bc1a4 100644
+--- a/ir/ts/tsPrivateIdentifier.cpp
++++ b/ir/ts/tsPrivateIdentifier.cpp
+@@ -27,8 +27,8 @@ void TSPrivateIdentifier::Iterate(const NodeTraverser &cb) const
+         cb(value_);
+     }
+ 
+-    if (typeAnnotation_) {
+-        cb(typeAnnotation_);
++    if (type_annotation_) {
++        cb(type_annotation_);
+     }
+ }
+ 
+@@ -37,7 +37,7 @@ void TSPrivateIdentifier::Dump(ir::AstDumper *dumper) const
+     dumper->Add({{"type", "TSPrivateIdentifier"},
+                  {"key", key_},
+                  {"value", AstDumper::Optional(value_)},
+-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)}});
++                 {"typeAnnotation", AstDumper::Optional(type_annotation_)}});
+ }
+ 
+ void TSPrivateIdentifier::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsPrivateIdentifier.h b/ir/ts/tsPrivateIdentifier.h
+index e4872d5..e356816 100644
+--- a/ir/ts/tsPrivateIdentifier.h
++++ b/ir/ts/tsPrivateIdentifier.h
+@@ -32,7 +32,7 @@ namespace panda::es2panda::ir {
+ class TSPrivateIdentifier : public Expression {
+ public:
+     explicit TSPrivateIdentifier(Expression *key, Expression *value, Expression *typeAnnotation)
+-        : Expression(AstNodeType::TS_PRIVATE_IDENTIFIER), key_(key), value_(value), typeAnnotation_(typeAnnotation)
++        : Expression(AstNodeType::TS_PRIVATE_IDENTIFIER), key_(key), value_(value), type_annotation_(typeAnnotation)
+     {
+     }
+ 
+@@ -48,7 +48,7 @@ public:
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -59,7 +59,7 @@ public:
+ private:
+     Expression *key_;
+     Expression *value_;
+-    Expression *typeAnnotation_;
++    Expression *type_annotation_;
+ };
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsPropertySignature.cpp b/ir/ts/tsPropertySignature.cpp
+index 1e91a37..6288866 100644
+--- a/ir/ts/tsPropertySignature.cpp
++++ b/ir/ts/tsPropertySignature.cpp
+@@ -23,8 +23,8 @@ void TSPropertySignature::Iterate(const NodeTraverser &cb) const
+ {
+     cb(key_);
+ 
+-    if (typeAnnotation_) {
+-        cb(typeAnnotation_);
++    if (type_annotation_) {
++        cb(type_annotation_);
+     }
+ }
+ 
+@@ -35,7 +35,7 @@ void TSPropertySignature::Dump(ir::AstDumper *dumper) const
+                  {"optional", optional_},
+                  {"readonly", readonly_},
+                  {"key", key_},
+-                 {"typeAnnotation", AstDumper::Optional(typeAnnotation_)}});
++                 {"typeAnnotation", AstDumper::Optional(type_annotation_)}});
+ }
+ 
+ void TSPropertySignature::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsPropertySignature.h b/ir/ts/tsPropertySignature.h
+index 9b9b9a0..7ed401a 100644
+--- a/ir/ts/tsPropertySignature.h
++++ b/ir/ts/tsPropertySignature.h
+@@ -35,7 +35,7 @@ public:
+                                  bool readonly)
+         : Expression(AstNodeType::TS_PROPERTY_SIGNATURE),
+           key_(key),
+-          typeAnnotation_(typeAnnotation),
++          type_annotation_(typeAnnotation),
+           computed_(computed),
+           optional_(optional),
+           readonly_(readonly)
+@@ -49,7 +49,7 @@ public:
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     bool Computed() const
+@@ -74,7 +74,7 @@ public:
+ 
+ private:
+     Expression *key_;
+-    Expression *typeAnnotation_;
++    Expression *type_annotation_;
+     bool computed_;
+     bool optional_;
+     bool readonly_;
+diff --git a/ir/ts/tsSignatureDeclaration.cpp b/ir/ts/tsSignatureDeclaration.cpp
+index 1269e94..fc66598 100644
+--- a/ir/ts/tsSignatureDeclaration.cpp
++++ b/ir/ts/tsSignatureDeclaration.cpp
+@@ -24,16 +24,16 @@ namespace panda::es2panda::ir {
+ 
+ void TSSignatureDeclaration::Iterate(const NodeTraverser &cb) const
+ {
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+     for (auto *it : params_) {
+         cb(it);
+     }
+ 
+-    if (returnTypeAnnotation_) {
+-        cb(returnTypeAnnotation_);
++    if (return_type_annotation_) {
++        cb(return_type_annotation_);
+     }
+ }
+ 
+@@ -43,8 +43,8 @@ void TSSignatureDeclaration::Dump(ir::AstDumper *dumper) const
+                               ? "TSCallSignatureDeclaration"
+                               : "TSConstructSignatureDeclaration"},
+                  {"params", params_},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)},
+-                 {"returnType", AstDumper::Optional(returnTypeAnnotation_)}});
++                 {"typeParameters", AstDumper::Optional(type_params_)},
++                 {"returnType", AstDumper::Optional(return_type_annotation_)}});
+ }
+ 
+ void TSSignatureDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsSignatureDeclaration.h b/ir/ts/tsSignatureDeclaration.h
+index 85a8fe6..6ec14f8 100644
+--- a/ir/ts/tsSignatureDeclaration.h
++++ b/ir/ts/tsSignatureDeclaration.h
+@@ -45,9 +45,9 @@ public:
+         : Expression(AstNodeType::TS_SIGNATURE_DECLARATION),
+           scope_(scope),
+           kind_(kind),
+-          typeParams_(typeParams),
++          type_params_(typeParams),
+           params_(std::move(params)),
+-          returnTypeAnnotation_(returnTypeAnnotation)
++          return_type_annotation_(returnTypeAnnotation)
+     {
+     }
+     binder::Scope *Scope() const
+@@ -57,7 +57,7 @@ public:
+ 
+     const TSTypeParameterDeclaration *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     const ArenaVector<Expression *> &Params() const
+@@ -67,7 +67,7 @@ public:
+ 
+     const Expression *ReturnTypeAnnotation() const
+     {
+-        return returnTypeAnnotation_;
++        return return_type_annotation_;
+     }
+ 
+     TSSignatureDeclarationKind Kind() const
+@@ -83,9 +83,9 @@ public:
+ private:
+     binder::Scope *scope_;
+     TSSignatureDeclarationKind kind_;
+-    TSTypeParameterDeclaration *typeParams_;
++    TSTypeParameterDeclaration *type_params_;
+     ArenaVector<Expression *> params_;
+-    Expression *returnTypeAnnotation_;
++    Expression *return_type_annotation_;
+ };
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsTupleType.cpp b/ir/ts/tsTupleType.cpp
+index fb835d7..2ae30ee 100644
+--- a/ir/ts/tsTupleType.cpp
++++ b/ir/ts/tsTupleType.cpp
+@@ -27,14 +27,14 @@ namespace panda::es2panda::ir {
+ 
+ void TSTupleType::Iterate(const NodeTraverser &cb) const
+ {
+-    for (auto *it : elementTypes_) {
++    for (auto *it : element_types_) {
+         cb(it);
+     }
+ }
+ 
+ void TSTupleType::Dump(ir::AstDumper *dumper) const
+ {
+-    dumper->Add({{"type", "TSTupleType"}, {"elementTypes", elementTypes_}});
++    dumper->Add({{"type", "TSTupleType"}, {"elementTypes", element_types_}});
+ }
+ 
+ void TSTupleType::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+@@ -48,7 +48,7 @@ checker::Type *TSTupleType::Check(checker::Checker *checker) const
+     uint32_t minLength = 0;
+     uint32_t index = 0;
+     std::vector<checker::Type *> numberIndexTypes;
+-    for (auto *it : elementTypes_) {
++    for (auto *it : element_types_) {
+         util::StringView memberIndex = util::Helpers::ToStringView(checker->Allocator(), index);
+ 
+         auto *memberVar =
+@@ -83,11 +83,11 @@ checker::Type *TSTupleType::Check(checker::Checker *checker) const
+         combinedFlags |= memberFlag;
+ 
+         elementFlags.insert({memberIndex, memberFlag});
+-        desc->properties.push_back(memberVar);
++        desc->properties_.push_back(memberVar);
+         index++;
+     }
+ 
+-    uint32_t fixedLength = desc->properties.size();
++    uint32_t fixedLength = desc->properties_.size();
+ 
+     checker::Type *numberIndexType = nullptr;
+ 
+@@ -99,7 +99,7 @@ checker::Type *TSTupleType::Check(checker::Checker *checker) const
+         numberIndexType = checker->CreateUnionType(std::move(numberIndexTypes));
+     }
+ 
+-    desc->numberIndexInfo = checker->Allocator()->New<checker::IndexInfo>(numberIndexType, "x");
++    desc->number_index_info_ = checker->Allocator()->New<checker::IndexInfo>(numberIndexType, "x");
+ 
+     return checker->CreateTupleType(desc, std::move(elementFlags), combinedFlags, minLength, fixedLength, false,
+                                     std::move(namedMembers));
+diff --git a/ir/ts/tsTupleType.h b/ir/ts/tsTupleType.h
+index 6e7adec..e488d82 100644
+--- a/ir/ts/tsTupleType.h
++++ b/ir/ts/tsTupleType.h
+@@ -34,13 +34,13 @@ enum class TSTupleKind { NONE, NAMED, DEFAULT };
+ class TSTupleType : public Expression {
+ public:
+     explicit TSTupleType(ArenaVector<Expression *> &&elementTypes)
+-        : Expression(AstNodeType::TS_TUPLE_TYPE), elementTypes_(std::move(elementTypes))
++        : Expression(AstNodeType::TS_TUPLE_TYPE), element_types_(std::move(elementTypes))
+     {
+     }
+ 
+     const ArenaVector<Expression *> &ElementType() const
+     {
+-        return elementTypes_;
++        return element_types_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -49,7 +49,7 @@ public:
+     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+ 
+ private:
+-    ArenaVector<Expression *> elementTypes_;
++    ArenaVector<Expression *> element_types_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsTypeAliasDeclaration.cpp b/ir/ts/tsTypeAliasDeclaration.cpp
+index 48b9590..c60dbb0 100644
+--- a/ir/ts/tsTypeAliasDeclaration.cpp
++++ b/ir/ts/tsTypeAliasDeclaration.cpp
+@@ -28,19 +28,19 @@ void TSTypeAliasDeclaration::Iterate(const NodeTraverser &cb) const
+ {
+     cb(id_);
+ 
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+-    cb(typeAnnotation_);
++    cb(type_annotation_);
+ }
+ 
+ void TSTypeAliasDeclaration::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TSTypeAliasDeclaration"},
+                  {"id", id_},
+-                 {"typeAnnotation", typeAnnotation_},
+-                 {"typeParameters", AstDumper::Optional(typeParams_)},
++                 {"typeAnnotation", type_annotation_},
++                 {"typeParameters", AstDumper::Optional(type_params_)},
+                  {"declare", AstDumper::Optional(declare_)}});
+ }
+ 
+@@ -49,7 +49,7 @@ void TSTypeAliasDeclaration::Compile([[maybe_unused]] compiler::PandaGen *pg) co
+ checker::Type *TSTypeAliasDeclaration::CheckTypeAnnotation(checker::Checker *checker,
+                                                            binder::Variable *bindingVar) const
+ {
+-    checker::Type *aliasType = typeAnnotation_->Check(checker);
++    checker::Type *aliasType = type_annotation_->Check(checker);
+     aliasType->SetVariable(bindingVar);
+     bindingVar->SetTsType(aliasType);
+ 
+@@ -58,9 +58,9 @@ checker::Type *TSTypeAliasDeclaration::CheckTypeAnnotation(checker::Checker *che
+ 
+ checker::Type *TSTypeAliasDeclaration::InferType(checker::Checker *checker, binder::Variable *bindingVar) const
+ {
+-    if (typeParams_) {
+-        checker::ScopeContext scopeCtx(checker, typeParams_->Scope());
+-        checker->CheckTypeParameters(typeParams_);
++    if (type_params_) {
++        checker::ScopeContext scopeCtx(checker, type_params_->Scope());
++        checker->CheckTypeParameters(type_params_);
+         return CheckTypeAnnotation(checker, bindingVar);
+     }
+ 
+@@ -71,10 +71,10 @@ checker::Type *TSTypeAliasDeclaration::Check([[maybe_unused]] checker::Checker *
+ {
+     const util::StringView &aliasName = id_->Name();
+     binder::ScopeFindResult result = checker->Scope()->Find(aliasName);
+-    ASSERT(result.variable);
++    ASSERT(result.variable_);
+ 
+-    if (!result.variable->TsType()) {
+-        InferType(checker, result.variable);
++    if (!result.variable_->TsType()) {
++        InferType(checker, result.variable_);
+     }
+ 
+     return nullptr;
+diff --git a/ir/ts/tsTypeAliasDeclaration.h b/ir/ts/tsTypeAliasDeclaration.h
+index f882d51..f0976c6 100644
+--- a/ir/ts/tsTypeAliasDeclaration.h
++++ b/ir/ts/tsTypeAliasDeclaration.h
+@@ -42,8 +42,8 @@ public:
+                                     bool declare)
+         : Statement(AstNodeType::TS_TYPE_ALIAS_DECLARATION),
+           id_(id),
+-          typeParams_(typeParams),
+-          typeAnnotation_(typeAnnotation),
++          type_params_(typeParams),
++          type_annotation_(typeAnnotation),
+           declare_(declare)
+     {
+     }
+@@ -55,12 +55,12 @@ public:
+ 
+     const TSTypeParameterDeclaration *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     bool Declare() const
+@@ -78,8 +78,8 @@ private:
+     checker::Type *CheckTypeAnnotation(checker::Checker *checker, binder::Variable *bindingVar) const;
+ 
+     Identifier *id_;
+-    TSTypeParameterDeclaration *typeParams_;
+-    Expression *typeAnnotation_;
++    TSTypeParameterDeclaration *type_params_;
++    Expression *type_annotation_;
+     bool declare_;
+ };
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsTypeAssertion.cpp b/ir/ts/tsTypeAssertion.cpp
+index 90ed300..216bdd5 100644
+--- a/ir/ts/tsTypeAssertion.cpp
++++ b/ir/ts/tsTypeAssertion.cpp
+@@ -21,13 +21,13 @@ namespace panda::es2panda::ir {
+ 
+ void TSTypeAssertion::Iterate(const NodeTraverser &cb) const
+ {
+-    cb(typeAnnotation_);
++    cb(type_annotation_);
+     cb(expression_);
+ }
+ 
+ void TSTypeAssertion::Dump(ir::AstDumper *dumper) const
+ {
+-    dumper->Add({{"type", "TSTypeAssertion"}, {"typeAnnotation", typeAnnotation_}, {"expression", expression_}});
++    dumper->Add({{"type", "TSTypeAssertion"}, {"typeAnnotation", type_annotation_}, {"expression", expression_}});
+ }
+ 
+ void TSTypeAssertion::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+diff --git a/ir/ts/tsTypeAssertion.h b/ir/ts/tsTypeAssertion.h
+index d23ba49..ac3a1c7 100644
+--- a/ir/ts/tsTypeAssertion.h
++++ b/ir/ts/tsTypeAssertion.h
+@@ -32,13 +32,13 @@ namespace panda::es2panda::ir {
+ class TSTypeAssertion : public Expression {
+ public:
+     explicit TSTypeAssertion(Expression *typeAnnotation, Expression *expression)
+-        : Expression(AstNodeType::TS_TYPE_ASSERTION), typeAnnotation_(typeAnnotation), expression_(expression)
++        : Expression(AstNodeType::TS_TYPE_ASSERTION), type_annotation_(typeAnnotation), expression_(expression)
+     {
+     }
+ 
+     const Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     const Expression *GetExpression() const
+@@ -52,7 +52,7 @@ public:
+     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+ 
+ private:
+-    Expression *typeAnnotation_;
++    Expression *type_annotation_;
+     Expression *expression_;
+ };
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsTypeOperator.cpp b/ir/ts/tsTypeOperator.cpp
+index bd17dba..7dcd328 100644
+--- a/ir/ts/tsTypeOperator.cpp
++++ b/ir/ts/tsTypeOperator.cpp
+@@ -28,7 +28,7 @@ void TSTypeOperator::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({
+         {"type", "TSTypeOperator"},
+-        {"operator", AstDumper::TypeOperatorToString(operatorType_)},
++        {"operator", AstDumper::TypeOperatorToString(operator_type_)},
+         {"typeAnnotation", type_},
+     });
+ }
+diff --git a/ir/ts/tsTypeOperator.h b/ir/ts/tsTypeOperator.h
+index 8cbefb6..01aad3a 100644
+--- a/ir/ts/tsTypeOperator.h
++++ b/ir/ts/tsTypeOperator.h
+@@ -32,7 +32,7 @@ namespace panda::es2panda::ir {
+ class TSTypeOperator : public Expression {
+ public:
+     explicit TSTypeOperator(Expression *type, TSOperatorType operatorType)
+-        : Expression(AstNodeType::TS_TYPE_OPERATOR), type_(type), operatorType_(operatorType)
++        : Expression(AstNodeType::TS_TYPE_OPERATOR), type_(type), operator_type_(operatorType)
+     {
+     }
+ 
+@@ -43,17 +43,17 @@ public:
+ 
+     bool IsReadonly() const
+     {
+-        return operatorType_ == TSOperatorType::READONLY;
++        return operator_type_ == TSOperatorType::READONLY;
+     }
+ 
+     bool IsKeyof() const
+     {
+-        return operatorType_ == TSOperatorType::KEYOF;
++        return operator_type_ == TSOperatorType::KEYOF;
+     }
+ 
+     bool IsUnique() const
+     {
+-        return operatorType_ == TSOperatorType::UNIQUE;
++        return operator_type_ == TSOperatorType::UNIQUE;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -63,7 +63,7 @@ public:
+ 
+ private:
+     Expression *type_;
+-    TSOperatorType operatorType_;
++    TSOperatorType operator_type_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsTypeParameter.cpp b/ir/ts/tsTypeParameter.cpp
+index 462c53b..33e4772 100644
+--- a/ir/ts/tsTypeParameter.cpp
++++ b/ir/ts/tsTypeParameter.cpp
+@@ -28,8 +28,8 @@ void TSTypeParameter::Iterate(const NodeTraverser &cb) const
+         cb(constraint_);
+     }
+ 
+-    if (defaultType_) {
+-        cb(defaultType_);
++    if (default_type_) {
++        cb(default_type_);
+     }
+ }
+ 
+@@ -39,7 +39,7 @@ void TSTypeParameter::Dump(ir::AstDumper *dumper) const
+         {"type", "TSTypeParameter"},
+         {"name", name_},
+         {"constraint", AstDumper::Optional(constraint_)},
+-        {"default", AstDumper::Optional(defaultType_)},
++        {"default", AstDumper::Optional(default_type_)},
+     });
+ }
+ 
+diff --git a/ir/ts/tsTypeParameter.h b/ir/ts/tsTypeParameter.h
+index fb6d2c0..845e315 100644
+--- a/ir/ts/tsTypeParameter.h
++++ b/ir/ts/tsTypeParameter.h
+@@ -34,7 +34,7 @@ class Identifier;
+ class TSTypeParameter : public Expression {
+ public:
+     explicit TSTypeParameter(Identifier *name, Expression *constraint, Expression *defaultType)
+-        : Expression(AstNodeType::TS_TYPE_PARAMETER), name_(name), constraint_(constraint), defaultType_(defaultType)
++        : Expression(AstNodeType::TS_TYPE_PARAMETER), name_(name), constraint_(constraint), default_type_(defaultType)
+     {
+     }
+ 
+@@ -50,7 +50,7 @@ public:
+ 
+     const Expression *DefaultType() const
+     {
+-        return defaultType_;
++        return default_type_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -61,7 +61,7 @@ public:
+ private:
+     Identifier *name_;
+     Expression *constraint_;
+-    Expression *defaultType_;
++    Expression *default_type_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsTypeParameterDeclaration.h b/ir/ts/tsTypeParameterDeclaration.h
+index d8b0954..a090ef2 100644
+--- a/ir/ts/tsTypeParameterDeclaration.h
++++ b/ir/ts/tsTypeParameterDeclaration.h
+@@ -42,7 +42,7 @@ public:
+         : Expression(AstNodeType::TS_TYPE_PARAMETER_DECLARATION),
+           scope_(scope),
+           params_(std::move(params)),
+-          requiredParams_(requiredParams)
++          required_params_(requiredParams)
+     {
+     }
+ 
+@@ -58,7 +58,7 @@ public:
+ 
+     size_t RequiredParams() const
+     {
+-        return requiredParams_;
++        return required_params_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -69,7 +69,7 @@ public:
+ private:
+     binder::LocalScope *scope_;
+     ArenaVector<TSTypeParameter *> params_;
+-    size_t requiredParams_;
++    size_t required_params_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsTypePredicate.cpp b/ir/ts/tsTypePredicate.cpp
+index d5cd205..61cb4f2 100644
+--- a/ir/ts/tsTypePredicate.cpp
++++ b/ir/ts/tsTypePredicate.cpp
+@@ -22,17 +22,17 @@ namespace panda::es2panda::ir {
+ 
+ void TSTypePredicate::Iterate(const NodeTraverser &cb) const
+ {
+-    cb(parameterName_);
+-    if (typeAnnotation_) {
+-        cb(typeAnnotation_);
++    cb(parameter_name_);
++    if (type_annotation_) {
++        cb(type_annotation_);
+     }
+ }
+ 
+ void TSTypePredicate::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add({{"type", "TSTypePredicate"},
+-                 {"parameterName", parameterName_},
+-                 {"typeAnnotation", AstDumper::Nullable(typeAnnotation_)},
++                 {"parameterName", parameter_name_},
++                 {"typeAnnotation", AstDumper::Nullable(type_annotation_)},
+                  {"asserts", asserts_}});
+ }
+ 
+diff --git a/ir/ts/tsTypePredicate.h b/ir/ts/tsTypePredicate.h
+index 3ebc932..f7b68ad 100644
+--- a/ir/ts/tsTypePredicate.h
++++ b/ir/ts/tsTypePredicate.h
+@@ -33,20 +33,20 @@ class TSTypePredicate : public Expression {
+ public:
+     explicit TSTypePredicate(Expression *parameterName, Expression *typeAnnotation, bool asserts)
+         : Expression(AstNodeType::TS_TYPE_PREDICATE),
+-          parameterName_(parameterName),
+-          typeAnnotation_(typeAnnotation),
++          parameter_name_(parameterName),
++          type_annotation_(typeAnnotation),
+           asserts_(asserts)
+     {
+     }
+ 
+     Expression *ParameterName() const
+     {
+-        return parameterName_;
++        return parameter_name_;
+     }
+ 
+     Expression *TypeAnnotation() const
+     {
+-        return typeAnnotation_;
++        return type_annotation_;
+     }
+ 
+     bool Asserts() const
+@@ -60,8 +60,8 @@ public:
+     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+ 
+ private:
+-    Expression *parameterName_;
+-    Expression *typeAnnotation_;
++    Expression *parameter_name_;
++    Expression *type_annotation_;
+     bool asserts_;
+ };
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsTypeQuery.cpp b/ir/ts/tsTypeQuery.cpp
+index 917bfed..593f637 100644
+--- a/ir/ts/tsTypeQuery.cpp
++++ b/ir/ts/tsTypeQuery.cpp
+@@ -21,20 +21,20 @@ namespace panda::es2panda::ir {
+ 
+ void TSTypeQuery::Iterate(const NodeTraverser &cb) const
+ {
+-    cb(exprName_);
++    cb(expr_name_);
+ }
+ 
+ void TSTypeQuery::Dump(ir::AstDumper *dumper) const
+ {
+-    dumper->Add({{"type", "TSTypeQuery"}, {"exprName", exprName_}});
++    dumper->Add({{"type", "TSTypeQuery"}, {"exprName", expr_name_}});
+ }
+ 
+ void TSTypeQuery::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+ 
+ checker::Type *TSTypeQuery::Check([[maybe_unused]] checker::Checker *checker) const
+ {
+-    ASSERT(exprName_->IsIdentifier() || exprName_->IsTSQualifiedName());
+-    return exprName_->Check(checker);
++    ASSERT(expr_name_->IsIdentifier() || expr_name_->IsTSQualifiedName());
++    return expr_name_->Check(checker);
+ }
+ 
+ }  // namespace panda::es2panda::ir
+diff --git a/ir/ts/tsTypeQuery.h b/ir/ts/tsTypeQuery.h
+index 060a2c1..8a5f934 100644
+--- a/ir/ts/tsTypeQuery.h
++++ b/ir/ts/tsTypeQuery.h
+@@ -31,11 +31,11 @@ namespace panda::es2panda::ir {
+ 
+ class TSTypeQuery : public Expression {
+ public:
+-    explicit TSTypeQuery(Expression *exprName) : Expression(AstNodeType::TS_TYPE_QUERY), exprName_(exprName) {}
++    explicit TSTypeQuery(Expression *exprName) : Expression(AstNodeType::TS_TYPE_QUERY), expr_name_(exprName) {}
+ 
+     const Expression *ExprName() const
+     {
+-        return exprName_;
++        return expr_name_;
+     }
+ 
+     void Iterate(const NodeTraverser &cb) const override;
+@@ -44,7 +44,7 @@ public:
+     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+ 
+ private:
+-    Expression *exprName_;
++    Expression *expr_name_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/ts/tsTypeReference.cpp b/ir/ts/tsTypeReference.cpp
+index 8585952..6507829 100644
+--- a/ir/ts/tsTypeReference.cpp
++++ b/ir/ts/tsTypeReference.cpp
+@@ -30,29 +30,30 @@ namespace panda::es2panda::ir {
+ 
+ void TSTypeReference::Iterate(const NodeTraverser &cb) const
+ {
+-    if (typeParams_) {
+-        cb(typeParams_);
++    if (type_params_) {
++        cb(type_params_);
+     }
+ 
+-    cb(typeName_);
++    cb(type_name_);
+ }
+ 
+ void TSTypeReference::Dump(ir::AstDumper *dumper) const
+ {
+     dumper->Add(
+-        {{"type", "TSTypeReference"}, {"typeName", typeName_}, {"typeParameters", AstDumper::Optional(typeParams_)}});
++        {{"type", "TSTypeReference"}, {"typeName", type_name_}, {"typeParameters", AstDumper::Optional(type_params_)}});
+ }
+ 
+ void TSTypeReference::Compile([[maybe_unused]] compiler::PandaGen *pg) const {}
+ 
+ checker::Type *TSTypeReference::Check([[maybe_unused]] checker::Checker *checker) const
+ {
+-    if (typeName_->IsIdentifier()) {
+-        return ResolveReference(checker, typeName_->AsIdentifier()->Variable(), typeName_->AsIdentifier(), typeParams_);
++    if (type_name_->IsIdentifier()) {
++        return ResolveReference(checker, type_name_->AsIdentifier()->Variable(), type_name_->AsIdentifier(),
++                                type_params_);
+     }
+ 
+-    ASSERT(typeName_->IsTSQualifiedName());
+-    return typeName_->Check(checker);
++    ASSERT(type_name_->IsTSQualifiedName());
++    return type_name_->Check(checker);
+ }
+ 
+ checker::Type *TSTypeReference::ResolveReference(checker::Checker *checker, binder::Variable *var,
+diff --git a/ir/ts/tsTypeReference.h b/ir/ts/tsTypeReference.h
+index 40f024a..7c97ed1 100644
+--- a/ir/ts/tsTypeReference.h
++++ b/ir/ts/tsTypeReference.h
+@@ -39,18 +39,18 @@ class TSTypeParameterInstantiation;
+ class TSTypeReference : public Expression {
+ public:
+     explicit TSTypeReference(Expression *typeName, TSTypeParameterInstantiation *typeParams)
+-        : Expression(AstNodeType::TS_TYPE_REFERENCE), typeName_(typeName), typeParams_(typeParams)
++        : Expression(AstNodeType::TS_TYPE_REFERENCE), type_name_(typeName), type_params_(typeParams)
+     {
+     }
+ 
+     const TSTypeParameterInstantiation *TypeParams() const
+     {
+-        return typeParams_;
++        return type_params_;
+     }
+ 
+     const Expression *TypeName() const
+     {
+-        return typeName_;
++        return type_name_;
+     }
+ 
+     static checker::Type *ResolveReference(checker::Checker *checker, binder::Variable *var,
+@@ -63,8 +63,8 @@ public:
+     checker::Type *Check([[maybe_unused]] checker::Checker *checker) const override;
+ 
+ private:
+-    Expression *typeName_;
+-    TSTypeParameterInstantiation *typeParams_;
++    Expression *type_name_;
++    TSTypeParameterInstantiation *type_params_;
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/ir/validationInfo.h b/ir/validationInfo.h
+index 26b0446..d8ba9db 100644
+--- a/ir/validationInfo.h
++++ b/ir/validationInfo.h
+@@ -23,15 +23,15 @@ namespace panda::es2panda::ir {
+ class ValidationInfo {
+ public:
+     ValidationInfo() noexcept = default;
+-    ValidationInfo(util::StringView m, lexer::SourcePosition p) noexcept : msg(m), pos(p) {}
++    ValidationInfo(util::StringView m, lexer::SourcePosition p) noexcept : msg_(m), pos_(p) {}
+ 
+     inline bool Fail() const
+     {
+-        return !msg.Empty();
++        return !msg_.Empty();
+     }
+ 
+-    util::StringView msg {};
+-    lexer::SourcePosition pos {};
++    util::StringView msg_ {};
++    lexer::SourcePosition pos_ {};
+ };
+ }  // namespace panda::es2panda::ir
+ 
+diff --git a/lexer/keywordString.h b/lexer/keywordString.h
+index fcc8c13..24ec525 100644
+--- a/lexer/keywordString.h
++++ b/lexer/keywordString.h
+@@ -23,13 +23,13 @@
+ namespace panda::es2panda::lexer {
+ 
+ struct KeywordString {
+-    constexpr KeywordString(std::string_view s, TokenType t, TokenType k) : str(s), tokenType(t), keywordType(k) {}
++    constexpr KeywordString(std::string_view s, TokenType t, TokenType k) : str_(s), token_type_(t), keyword_type_(k) {}
+ 
+-    explicit KeywordString(std::string_view &s) : str(s) {}
++    explicit KeywordString(std::string_view &s) : str_(s) {}
+ 
+-    std::string_view str;
+-    TokenType tokenType {};
+-    TokenType keywordType {};
++    std::string_view str_;
++    TokenType token_type_ {};
++    TokenType keyword_type_ {};
+ };
+ 
+ }  // namespace panda::es2panda::lexer
+diff --git a/lexer/keywordsUtil.cpp b/lexer/keywordsUtil.cpp
+index 452a122..618abff 100644
+--- a/lexer/keywordsUtil.cpp
++++ b/lexer/keywordsUtil.cpp
+@@ -207,7 +207,7 @@ void KeywordsUtil::ScanIdentifierStart(char32_t cp)
+ void KeywordsUtil::ScanIdContinue()
+ {
+     util::UString ident(lexer_->Allocator());
+-    size_t startPos = lexer_->GetToken().Start().index;
++    size_t startPos = lexer_->GetToken().Start().index_;
+ 
+     if (HasEscape()) {
+         ident.Append(cp_);
+@@ -240,7 +240,7 @@ void KeywordsUtil::ScanIdContinue()
+     } while (true);
+ 
+     lexer_->GetToken().type_ = TokenType::LITERAL_IDENT;
+-    lexer_->GetToken().keywordType_ = TokenType::EOS;
++    lexer_->GetToken().keyword_type_ = TokenType::EOS;
+ 
+     if (HasEscape()) {
+         ident.Append(lexer_->SourceView(escapeEnd, Iterator().Index()));
+@@ -267,7 +267,7 @@ void KeywordsUtil::ScanIdContinueMaybeKeyword(Span<const KeywordString> map)
+     while (true) {
+         const auto &kws = map[middle];
+ 
+-        int relation = str.compare(kws.str);
++        int relation = str.compare(kws.str_);
+         if (relation == 0) {
+             Keywords::SetKeyword(this, kws);
+         }
+diff --git a/lexer/keywordsUtil.h b/lexer/keywordsUtil.h
+index 245a6dd..321d2e0 100644
+--- a/lexer/keywordsUtil.h
++++ b/lexer/keywordsUtil.h
+@@ -72,7 +72,7 @@ inline void KeywordsUtil::SetKeyword(std::string_view str, TokenType type)
+ {
+     lexer_->GetToken().src_ = util::StringView(str);
+     // NOLINTNEXTLINE
+-    lexer_->GetToken().keywordType_ = keyword_type;
++    lexer_->GetToken().keyword_type_ = keyword_type;
+ 
+     if (flags_ & lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT) {
+         lexer_->GetToken().type_ = TokenType::LITERAL_IDENT;
+diff --git a/lexer/lexer.cpp b/lexer/lexer.cpp
+index 8805271..4bc555d 100644
+--- a/lexer/lexer.cpp
++++ b/lexer/lexer.cpp
+@@ -25,11 +25,11 @@
+ 
+ namespace panda::es2panda::lexer {
+ 
+-LexerPosition::LexerPosition(const util::StringView &source) : iterator(source) {}
++LexerPosition::LexerPosition(const util::StringView &source) : iterator_(source) {}
+ 
+ Lexer::Lexer(const parser::ParserContext *parserContext)
+     : allocator_(parserContext->GetProgram()->Allocator()),
+-      parserContext_(parserContext),
++      parser_context_(parserContext),
+       source_(parserContext->GetProgram()->SourceCode()),
+       pos_(source_)
+ {
+@@ -85,17 +85,17 @@ ArenaAllocator *Lexer::Allocator()
+ 
+ Token &Lexer::GetToken()
+ {
+-    return pos_.token;
++    return pos_.token_;
+ }
+ 
+ const Token &Lexer::GetToken() const
+ {
+-    return pos_.token;
++    return pos_.token_;
+ }
+ 
+ size_t Lexer::Line() const
+ {
+-    return pos_.line;
++    return pos_.line_;
+ }
+ 
+ LexerPosition Lexer::Save() const
+@@ -105,15 +105,15 @@ LexerPosition Lexer::Save() const
+ 
+ void Lexer::BackwardToken(TokenType type, size_t offset)
+ {
+-    pos_.token.type_ = type;
+-    pos_.iterator.Reset(GetToken().End().index - offset);
+-    pos_.nextTokenLine = 0;
++    pos_.token_.type_ = type;
++    pos_.iterator_.Reset(GetToken().End().index_ - offset);
++    pos_.next_token_line_ = 0;
+ }
+ 
+ void Lexer::ForwardToken(TokenType type, size_t offset)
+ {
+-    pos_.token.type_ = type;
+-    pos_.iterator.Forward(offset);
++    pos_.token_.type_ = type;
++    pos_.iterator_.Forward(offset);
+     SkipWhiteSpaces();
+ }
+ 
+@@ -149,7 +149,7 @@ void Lexer::SkipMultiLineComment()
+             case LEX_CHAR_CR:
+             case LEX_CHAR_LS:
+             case LEX_CHAR_PS: {
+-                pos_.nextTokenLine++;
++                pos_.next_token_line_++;
+                 continue;
+             }
+             case LEX_CHAR_ASTERISK: {
+@@ -183,7 +183,7 @@ void Lexer::SkipSingleLineComment()
+             case LEX_CHAR_LF:
+             case LEX_CHAR_LS:
+             case LEX_CHAR_PS: {
+-                pos_.nextTokenLine++;
++                pos_.next_token_line_++;
+                 return;
+             }
+             default: {
+@@ -195,7 +195,7 @@ void Lexer::SkipSingleLineComment()
+ 
+ void Lexer::ThrowError(std::string_view message)
+ {
+-    throw es2panda::Error(es2panda::ErrorType::SYNTAX, message, pos_.line, Iterator().Index());
++    throw es2panda::Error(es2panda::ErrorType::SYNTAX, message, pos_.line_, Iterator().Index());
+ }
+ 
+ void Lexer::CheckNumberLiteralEnd()
+@@ -205,7 +205,7 @@ void Lexer::CheckNumberLiteralEnd()
+         GetToken().flags_ |= TokenFlags::NUMBER_BIGINT;
+     }
+ 
+-    GetToken().src_ = SourceView(GetToken().Start().index, Iterator().Index());
++    GetToken().src_ = SourceView(GetToken().Start().index_, Iterator().Index());
+     const auto nextCp = Iterator().PeekCp();
+     if (KeywordsUtil::IsIdentifierStart(nextCp) || IsDecimalDigit(nextCp)) {
+         ThrowError("Invalid numeric literal");
+@@ -321,7 +321,7 @@ void Lexer::ScanDecimalNumbers(bool allowNumericSeparator)
+ 
+ void Lexer::ConvertNumber(size_t exponentSignPos)
+ {
+-    util::StringView sv = SourceView(GetToken().Start().index, Iterator().Index());
++    util::StringView sv = SourceView(GetToken().Start().index_, Iterator().Index());
+     std::string utf8 = std::string {sv.Utf8()};
+     bool needConversion = false;
+ 
+@@ -393,7 +393,7 @@ void Lexer::ScanNumber(bool allowNumericSeparator, bool allowBigInt)
+                     break;
+                 }
+                 default: {
+-                    exponentSignPos = Iterator().Index() - GetToken().Start().index;
++                    exponentSignPos = Iterator().Index() - GetToken().Start().index_;
+                     break;
+                 }
+             }
+@@ -424,7 +424,7 @@ void Lexer::ScanNumber(bool allowNumericSeparator, bool allowBigInt)
+ 
+ void Lexer::PushTemplateContext(TemplateLiteralParserContext *ctx)
+ {
+-    tlCtx_ = ctx;
++    tl_ctx_ = ctx;
+ }
+ 
+ void Lexer::ScanTemplateStringEnd()
+@@ -449,7 +449,7 @@ LexerTemplateString Lexer::ScanTemplateString()
+                 break;
+             }
+             case LEX_CHAR_BACK_TICK: {
+-                templateStr.end = Iterator().Index();
++                templateStr.end_ = Iterator().Index();
+                 return templateStr;
+             }
+             case LEX_CHAR_CR: {
+@@ -462,8 +462,8 @@ LexerTemplateString Lexer::ScanTemplateString()
+                 [[fallthrough]];
+             }
+             case LEX_CHAR_LF: {
+-                pos_.line++;
+-                templateStr.str.Append(LEX_CHAR_LF);
++                pos_.line_++;
++                templateStr.str_.Append(LEX_CHAR_LF);
+                 Iterator().Forward(1);
+                 continue;
+             }
+@@ -482,8 +482,8 @@ LexerTemplateString Lexer::ScanTemplateString()
+                 }
+ 
+                 if (nextCp == LEX_CHAR_BACK_TICK || nextCp == LEX_CHAR_BACKSLASH) {
+-                    templateStr.str.Append(cp);
+-                    templateStr.str.Append(nextCp);
++                    templateStr.str_.Append(cp);
++                    templateStr.str_.Append(nextCp);
+                     Iterator().Forward(1);
+                     continue;
+                 }
+@@ -492,17 +492,17 @@ LexerTemplateString Lexer::ScanTemplateString()
+                 break;
+             }
+             case LEX_CHAR_DOLLAR_SIGN: {
+-                templateStr.end = Iterator().Index();
++                templateStr.end_ = Iterator().Index();
+                 Iterator().Forward(1);
+ 
+                 if (Iterator().Peek() == LEX_CHAR_LEFT_BRACE) {
+                     Iterator().Forward(1);
+-                    templateStr.scanExpression = true;
++                    templateStr.scan_expression_ = true;
+                     SkipWhiteSpaces();
+                     return templateStr;
+                 }
+ 
+-                templateStr.str.Append(cp);
++                templateStr.str_.Append(cp);
+                 continue;
+             }
+             default: {
+@@ -510,7 +510,7 @@ LexerTemplateString Lexer::ScanTemplateString()
+             }
+         }
+ 
+-        templateStr.str.Append(cp);
++        templateStr.str_.Append(cp);
+         Iterator().Forward(cpSize);
+     }
+ 
+@@ -521,9 +521,9 @@ LexerTemplateString Lexer::ScanTemplateString()
+ void Lexer::ResetTokenEnd()
+ {
+     SetTokenStart();
+-    pos_.iterator.Reset(GetToken().End().index);
+-    pos_.line = GetToken().End().line;
+-    pos_.nextTokenLine = 0;
++    pos_.iterator_.Reset(GetToken().End().index_);
++    pos_.line_ = GetToken().End().line_;
++    pos_.next_token_line_ = 0;
+ }
+ 
+ void Lexer::ScanStringUnicodePart(util::UString *str)
+@@ -547,7 +547,7 @@ void Lexer::ScanStringUnicodePart(util::UString *str)
+         case LEX_CHAR_LS:
+         case LEX_CHAR_PS:
+         case LEX_CHAR_LF: {
+-            pos_.line++;
++            pos_.line_++;
+             Iterator().Forward(cpSize);
+             return;
+         }
+@@ -1144,30 +1144,30 @@ bool Lexer::CheckArrow()
+ 
+ void Lexer::SetTokenStart()
+ {
+-    if (pos_.nextTokenLine != 0) {
+-        pos_.line += pos_.nextTokenLine;
+-        pos_.nextTokenLine = 0;
++    if (pos_.next_token_line_ != 0) {
++        pos_.line_ += pos_.next_token_line_;
++        pos_.next_token_line_ = 0;
+         GetToken().flags_ = TokenFlags::NEW_LINE;
+     } else {
+         GetToken().flags_ = TokenFlags::NONE;
+     }
+ 
+-    pos_.token.loc_.start = SourcePosition {Iterator().Index(), pos_.line};
++    pos_.token_.loc_.start_ = SourcePosition {Iterator().Index(), pos_.line_};
+ }
+ 
+ void Lexer::SetTokenEnd()
+ {
+-    pos_.token.loc_.end = SourcePosition {Iterator().Index(), pos_.line};
++    pos_.token_.loc_.end_ = SourcePosition {Iterator().Index(), pos_.line_};
+ }
+ 
+ void Lexer::CheckAwaitKeyword()
+ {
+-    if (!parserContext_->IsAsync()) {
++    if (!parser_context_->IsAsync()) {
+         GetToken().type_ = TokenType::LITERAL_IDENT;
+         return;
+     }
+ 
+-    if (parserContext_->DisallowAwait()) {
++    if (parser_context_->DisallowAwait()) {
+         ThrowError("'await' is not allowed");
+     }
+ 
+@@ -1185,7 +1185,7 @@ void Lexer::CheckKeywordEscape(TokenType type)
+ 
+ void Lexer::CheckEnumKeyword()
+ {
+-    if (parserContext_->GetProgram()->Extension() == ScriptExtension::JS) {
++    if (parser_context_->GetProgram()->Extension() == ScriptExtension::JS) {
+         ThrowError("Unexpected reserved keyword");
+     }
+ 
+@@ -1203,7 +1203,7 @@ void Lexer::CheckLetKeyword()
+ 
+ void Lexer::CheckYieldKeyword()
+ {
+-    if (!parserContext_->AllowYield()) {
++    if (!parser_context_->AllowYield()) {
+         ThrowError("'yield' is not allowed");
+     }
+ 
+@@ -1214,7 +1214,7 @@ void Lexer::CheckFutureReservedKeyword(TokenType keywordType)
+ {
+     GetToken().type_ = TokenType::LITERAL_IDENT;
+ 
+-    if (parserContext_->GetProgram()->Extension() == ScriptExtension::TS && keywordType <= TokenType::KEYW_INTERFACE) {
++    if (parser_context_->GetProgram()->Extension() == ScriptExtension::TS && keywordType <= TokenType::KEYW_INTERFACE) {
+         return;
+     }
+ 
+@@ -1238,7 +1238,7 @@ void Lexer::SkipWhiteSpaces()
+             }
+             case LEX_CHAR_LF: {
+                 Iterator().Forward(1);
+-                pos_.nextTokenLine++;
++                pos_.next_token_line_++;
+                 continue;
+             }
+             case LEX_CHAR_VT:
+@@ -1276,7 +1276,7 @@ void Lexer::SkipWhiteSpaces()
+                 switch (cp) {
+                     case LEX_CHAR_LS:
+                     case LEX_CHAR_PS: {
+-                        pos_.nextTokenLine++;
++                        pos_.next_token_line_++;
+                         [[fallthrough]];
+                     }
+                     case LEX_CHAR_NBSP:
+@@ -1557,8 +1557,8 @@ void Lexer::NextToken(LexerNextTokenFlags flags)
+         case LEX_CHAR_LEFT_BRACE: {
+             GetToken().type_ = TokenType::PUNCTUATOR_LEFT_BRACE;
+ 
+-            if (tlCtx_) {
+-                tlCtx_->ConsumeLeftBrace();
++            if (tl_ctx_) {
++                tl_ctx_->ConsumeLeftBrace();
+             }
+ 
+             break;
+@@ -1570,7 +1570,7 @@ void Lexer::NextToken(LexerNextTokenFlags flags)
+         case LEX_CHAR_RIGHT_BRACE: {
+             GetToken().type_ = TokenType::PUNCTUATOR_RIGHT_BRACE;
+ 
+-            if (tlCtx_ && tlCtx_->ConsumeRightBrace()) {
++            if (tl_ctx_ && tl_ctx_->ConsumeRightBrace()) {
+                 SetTokenEnd();
+                 return;
+             }
+diff --git a/lexer/lexer.h b/lexer/lexer.h
+index b830227..8dd0805 100644
+--- a/lexer/lexer.h
++++ b/lexer/lexer.h
+@@ -43,22 +43,22 @@ public:
+     DEFAULT_MOVE_SEMANTIC(LexerPosition);
+     ~LexerPosition() = default;
+ 
+-    Token token {};
+-    util::StringView::Iterator iterator;
+-    size_t line {};
+-    size_t nextTokenLine {};
++    Token token_ {};
++    util::StringView::Iterator iterator_;
++    size_t line_ {};
++    size_t next_token_line_ {};
+ };
+ 
+ class LexerTemplateString {
+ public:
+-    explicit LexerTemplateString(ArenaAllocator *allocator) : str(allocator) {}
++    explicit LexerTemplateString(ArenaAllocator *allocator) : str_(allocator) {}
+     DEFAULT_COPY_SEMANTIC(LexerTemplateString);
+     DEFAULT_MOVE_SEMANTIC(LexerTemplateString);
+     ~LexerTemplateString() = default;
+ 
+-    util::UString str;
+-    size_t end {};
+-    bool scanExpression {};
++    util::UString str_;
++    size_t end_ {};
++    bool scan_expression_ {};
+ };
+ 
+ class TemplateLiteralParserContext;
+@@ -105,12 +105,12 @@ private:
+ 
+     inline util::StringView::Iterator &Iterator()
+     {
+-        return pos_.iterator;
++        return pos_.iterator_;
+     }
+ 
+     inline const util::StringView::Iterator &Iterator() const
+     {
+-        return pos_.iterator;
++        return pos_.iterator_;
+     }
+ 
+     util::StringView SourceView(const util::StringView::Iterator &begin, const util::StringView::Iterator &end) const;
+@@ -169,40 +169,40 @@ private:
+ 
+     friend class KeywordsUtil;
+     friend class TemplateLiteralParserContext;
+-    TemplateLiteralParserContext *tlCtx_ {};
++    TemplateLiteralParserContext *tl_ctx_ {};
+     ArenaAllocator *allocator_;
+-    const parser::ParserContext *parserContext_;
++    const parser::ParserContext *parser_context_;
+     util::StringView source_;
+     LexerPosition pos_;
+ };
+ 
+ class TemplateLiteralParserContext {
+ public:
+-    explicit TemplateLiteralParserContext(Lexer *lexer) : lexer_(lexer), prev_(lexer_->tlCtx_) {}
++    explicit TemplateLiteralParserContext(Lexer *lexer) : lexer_(lexer), prev_(lexer_->tl_ctx_) {}
+     NO_MOVE_SEMANTIC(TemplateLiteralParserContext);
+     NO_COPY_SEMANTIC(TemplateLiteralParserContext);
+ 
+     ~TemplateLiteralParserContext()
+     {
+-        lexer_->tlCtx_ = prev_;
++        lexer_->tl_ctx_ = prev_;
+     }
+ 
+     void ConsumeLeftBrace()
+     {
+-        braceDepth_++;
++        brace_depth_++;
+     }
+ 
+     bool ConsumeRightBrace()
+     {
+-        braceDepth_--;
++        brace_depth_--;
+ 
+-        return braceDepth_ == 0;
++        return brace_depth_ == 0;
+     }
+ 
+ private:
+     Lexer *lexer_;
+     TemplateLiteralParserContext *prev_ {};
+-    size_t braceDepth_ {1};
++    size_t brace_depth_ {1};
+ };
+ 
+ template <char32_t end>
+@@ -240,7 +240,7 @@ void Lexer::ScanString()
+                     }
+                 }
+ 
+-                pos_.line++;
++                pos_.line_++;
+                 str.Append(LEX_CHAR_LF);
+                 Iterator().Forward(1);
+                 escapeEnd = Iterator().Index();
+diff --git a/lexer/regexp/regexp.cpp b/lexer/regexp/regexp.cpp
+index 6140f29..b571a0e 100644
+--- a/lexer/regexp/regexp.cpp
++++ b/lexer/regexp/regexp.cpp
+@@ -22,20 +22,21 @@
+ 
+ namespace panda::es2panda::lexer {
+ 
+-RegExpError::RegExpError(std::string_view m) : message(m) {}
++RegExpError::RegExpError(std::string_view m) : message_(m) {}
+ 
+-RegExp::RegExp(util::StringView p, util::StringView f, RegExpFlags reFlags) : patternStr(p), flagsStr(f), flags(reFlags)
++RegExp::RegExp(util::StringView p, util::StringView f, RegExpFlags reFlags)
++    : pattern_str_(p), flags_str_(f), flags_(reFlags)
+ {
+ }
+ 
+ RegExpParser::RegExpParser(const RegExp &re, ArenaAllocator *allocator)
+-    : re_(re), allocator_ {allocator}, iter_(re_.patternStr)
++    : re_(re), allocator_ {allocator}, iter_(re_.pattern_str_)
+ {
+ }
+ 
+ bool RegExpParser::Unicode() const
+ {
+-    return (re_.flags & RegExpFlags::UNICODE) != 0;
++    return (re_.flags_ & RegExpFlags::UNICODE) != 0;
+ }
+ 
+ char32_t RegExpParser::Peek() const
+@@ -228,7 +229,7 @@ void RegExpParser::ParseNamedCapturingGroup()
+ {
+     util::StringView name = ParseIdent();
+ 
+-    auto result = groupNames_.insert(name);
++    auto result = group_names_.insert(name);
+     if (!result.second) {
+         ThrowError("Duplicate group name");
+     }
+@@ -238,7 +239,7 @@ void RegExpParser::ParseNamedCapturingGroup()
+ 
+ void RegExpParser::ParseCapturingGroup()
+ {
+-    capturingGroupCount_++;
++    capturing_group_count_++;
+ 
+     ParseDisjunction();
+ 
+@@ -536,7 +537,7 @@ uint32_t RegExpParser::ParseDecimalEscape()
+         decimalValue = newValue;
+     }
+ 
+-    if (decimalValue <= capturingGroupCount_) {
++    if (decimalValue <= capturing_group_count_) {
+         return decimalValue;
+     }
+ 
+@@ -689,7 +690,7 @@ void RegExpParser::ParseUnicodePropertyEscape()
+ 
+ void RegExpParser::ParseNamedBackreference()
+ {
+-    if (groupNames_.empty()) {
++    if (group_names_.empty()) {
+         /* Identity escape */
+         return;
+     }
+@@ -700,8 +701,8 @@ void RegExpParser::ParseNamedBackreference()
+ 
+     util::StringView name = ParseIdent();
+ 
+-    auto result = groupNames_.find(name);
+-    if (result == groupNames_.end()) {
++    auto result = group_names_.find(name);
++    if (result == group_names_.end()) {
+         ThrowError("Invalid named capture referenced");
+     }
+ }
+diff --git a/lexer/regexp/regexp.h b/lexer/regexp/regexp.h
+index e6a4be2..4a8379d 100644
+--- a/lexer/regexp/regexp.h
++++ b/lexer/regexp/regexp.h
+@@ -38,15 +38,15 @@ DEFINE_BITOPS(RegExpFlags)
+ class RegExpError : std::exception {
+ public:
+     explicit RegExpError(std::string_view m);
+-    std::string message;
++    std::string message_;
+ };
+ 
+ struct RegExp {
+     RegExp(util::StringView p, util::StringView f, RegExpFlags reFlags);
+ 
+-    util::StringView patternStr;
+-    util::StringView flagsStr;
+-    RegExpFlags flags;
++    util::StringView pattern_str_;
++    util::StringView flags_str_;
++    RegExpFlags flags_;
+ };
+ 
+ class RegExpParser {
+@@ -96,8 +96,8 @@ private:
+     RegExp re_;
+     ArenaAllocator *allocator_ {};
+     util::StringView::Iterator iter_;
+-    uint32_t capturingGroupCount_ {0};
+-    std::unordered_set<util::StringView> groupNames_;
++    uint32_t capturing_group_count_ {0};
++    std::unordered_set<util::StringView> group_names_;
+ };
+ 
+ }  // namespace panda::es2panda::lexer
+diff --git a/lexer/templates/keywords.h.erb b/lexer/templates/keywords.h.erb
+index fa2851a..c6e8e46 100644
+--- a/lexer/templates/keywords.h.erb
++++ b/lexer/templates/keywords.h.erb
+@@ -36,11 +36,11 @@ public:
+ 
+     // NOLINTNEXTLINE(readability-function-size)
+     static void SetKeyword(KeywordsUtil *util, const KeywordString& kws) {
+-        switch(kws.keywordType) {
++        switch(kws.keyword_type_) {
+ % keywords.each do |group|
+ %   group.each do |key, kw|
+         case <%= kw[1] %>: {
+-            return util->SetKeyword<<%= kw[1] %>>(kws.str, kws.tokenType);
++            return util->SetKeyword<<%= kw[1] %>>(kws.str_, kws.token_type_);
+         }
+ %   end
+ % end
+diff --git a/lexer/token/sourceLocation.cpp b/lexer/token/sourceLocation.cpp
+index 9d1e4ea..b37e7dc 100644
+--- a/lexer/token/sourceLocation.cpp
++++ b/lexer/token/sourceLocation.cpp
+@@ -26,17 +26,17 @@ void OffsetEntry::AddCol(size_t offset)
+     size_t diff = offset - offset_;
+     offset_ = offset;
+ 
+-    if (ranges.empty()) {
+-        ranges.emplace_back(Range {diff});
++    if (ranges_.empty()) {
++        ranges_.emplace_back(Range {diff});
+         return;
+     }
+ 
+-    auto &range = ranges.back();
++    auto &range = ranges_.back();
+ 
+-    if (diff == range.byteSize) {
+-        range.cnt++;
++    if (diff == range.byte_size_) {
++        range.cnt_++;
+     } else {
+-        ranges.emplace_back(Range {diff});
++        ranges_.emplace_back(Range {diff});
+     }
+ }
+ 
+@@ -72,20 +72,20 @@ LineIndex::LineIndex(const util::StringView &source) noexcept
+ 
+ SourceLocation LineIndex::GetLocation(SourcePosition pos) noexcept
+ {
+-    size_t line = pos.line;
++    size_t line = pos.line_;
+ 
+     size_t col = 0;
+-    const auto &entry = entrys_[pos.line];
+-    size_t diff = pos.index - entry.lineStart;
++    const auto &entry = entrys_[pos.line_];
++    size_t diff = pos.index_ - entry.line_start_;
+ 
+-    for (const auto &range : entry.ranges) {
+-        if (diff < range.cnt) {
++    for (const auto &range : entry.ranges_) {
++        if (diff < range.cnt_) {
+             col += diff;
+             break;
+         }
+ 
+-        diff -= range.cnt * range.byteSize;
+-        col += range.cnt;
++        diff -= range.cnt_ * range.byte_size_;
++        col += range.cnt_;
+     }
+ 
+     return SourceLocation(line + 1, col + 1);
+diff --git a/lexer/token/sourceLocation.h b/lexer/token/sourceLocation.h
+index 7f0fa27..5c99f5b 100644
+--- a/lexer/token/sourceLocation.h
++++ b/lexer/token/sourceLocation.h
+@@ -28,54 +28,54 @@ namespace panda::es2panda::lexer {
+ class SourcePosition {
+ public:
+     explicit SourcePosition() noexcept = default;
+-    explicit SourcePosition(size_t i, size_t l) noexcept : index(i), line(l) {}
++    explicit SourcePosition(size_t i, size_t l) noexcept : index_(i), line_(l) {}
+     DEFAULT_COPY_SEMANTIC(SourcePosition);
+     DEFAULT_MOVE_SEMANTIC(SourcePosition);
+     ~SourcePosition() = default;
+ 
+-    size_t index {};
+-    size_t line {};
++    size_t index_ {};
++    size_t line_ {};
+ };
+ 
+ class SourceRange {
+ public:
+     explicit SourceRange() noexcept = default;
+-    SourceRange(SourcePosition s, SourcePosition e) noexcept : start(s), end(e) {}
++    SourceRange(SourcePosition s, SourcePosition e) noexcept : start_(s), end_(e) {}
+     DEFAULT_COPY_SEMANTIC(SourceRange);
+     DEFAULT_MOVE_SEMANTIC(SourceRange);
+     ~SourceRange() = default;
+ 
+-    SourcePosition start {};
+-    SourcePosition end {};
++    SourcePosition start_ {};
++    SourcePosition end_ {};
+ };
+ 
+ class SourceLocation {
+ public:
+     explicit SourceLocation() noexcept = default;
+-    explicit SourceLocation(size_t l, size_t c) noexcept : line(l), col(c) {}
++    explicit SourceLocation(size_t l, size_t c) noexcept : line_(l), col_(c) {}
+     DEFAULT_COPY_SEMANTIC(SourceLocation);
+     DEFAULT_MOVE_SEMANTIC(SourceLocation);
+     ~SourceLocation() = default;
+ 
+-    size_t line {};
+-    size_t col {};
++    size_t line_ {};
++    size_t col_ {};
+ };
+ 
+ class Range {
+ public:
+-    explicit Range(size_t bS) noexcept : byteSize(bS) {}
++    explicit Range(size_t bS) noexcept : byte_size_(bS) {}
+ 
+     DEFAULT_COPY_SEMANTIC(Range);
+     DEFAULT_MOVE_SEMANTIC(Range);
+     ~Range() = default;
+ 
+-    size_t byteSize {};
+-    size_t cnt {1};
++    size_t byte_size_ {};
++    size_t cnt_ {1};
+ };
+ 
+ class OffsetEntry {
+ public:
+-    explicit OffsetEntry(size_t l) : lineStart(l), offset_(l) {};
++    explicit OffsetEntry(size_t l) : line_start_(l), offset_(l) {};
+ 
+     DEFAULT_COPY_SEMANTIC(OffsetEntry);
+     DEFAULT_MOVE_SEMANTIC(OffsetEntry);
+@@ -83,8 +83,8 @@ public:
+ 
+     void AddCol(size_t offset);
+ 
+-    std::vector<Range> ranges {};
+-    size_t lineStart {};
++    std::vector<Range> ranges_ {};
++    size_t line_start_ {};
+ 
+ private:
+     size_t offset_ {};
+diff --git a/lexer/token/token.cpp b/lexer/token/token.cpp
+index 12521b9..b848b1a 100644
+--- a/lexer/token/token.cpp
++++ b/lexer/token/token.cpp
+@@ -20,32 +20,32 @@ namespace panda::es2panda::lexer {
+ bool Token::IsAccessability() const
+ {
+     return (type_ == TokenType::LITERAL_IDENT &&
+-            (keywordType_ == TokenType::KEYW_PUBLIC || keywordType_ == TokenType::KEYW_PROTECTED ||
+-             keywordType_ == TokenType::KEYW_PRIVATE) &&
++            (keyword_type_ == TokenType::KEYW_PUBLIC || keyword_type_ == TokenType::KEYW_PROTECTED ||
++             keyword_type_ == TokenType::KEYW_PRIVATE) &&
+             !(flags_ & TokenFlags::HAS_ESCAPE));
+ }
+ 
+ bool Token::IsAsyncModifier() const
+ {
+-    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_ASYNC &&
++    return (type_ == TokenType::LITERAL_IDENT && keyword_type_ == TokenType::KEYW_ASYNC &&
+             !(flags_ & TokenFlags::HAS_ESCAPE));
+ }
+ 
+ bool Token::IsStaticModifier() const
+ {
+-    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_STATIC &&
++    return (type_ == TokenType::LITERAL_IDENT && keyword_type_ == TokenType::KEYW_STATIC &&
+             !(flags_ & TokenFlags::HAS_ESCAPE));
+ }
+ 
+ bool Token::IsDeclareModifier() const
+ {
+-    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_DECLARE &&
++    return (type_ == TokenType::LITERAL_IDENT && keyword_type_ == TokenType::KEYW_DECLARE &&
+             !(flags_ & TokenFlags::HAS_ESCAPE));
+ }
+ 
+ bool Token::IsReadonlyModifier() const
+ {
+-    return (type_ == TokenType::LITERAL_IDENT && keywordType_ == TokenType::KEYW_READONLY &&
++    return (type_ == TokenType::LITERAL_IDENT && keyword_type_ == TokenType::KEYW_READONLY &&
+             !(flags_ & TokenFlags::HAS_ESCAPE));
+ }
+ 
+@@ -76,7 +76,7 @@ bool Token::IsKeyword() const
+ 
+ bool Token::IsReservedTypeName() const
+ {
+-    switch (keywordType_) {
++    switch (keyword_type_) {
+         case TokenType::KEYW_ANY:
+         case TokenType::KEYW_UNKNOWN:
+         case TokenType::KEYW_NEVER:
+diff --git a/lexer/token/token.h b/lexer/token/token.h
+index 46a87d4..f23521a 100644
+--- a/lexer/token/token.h
++++ b/lexer/token/token.h
+@@ -60,17 +60,17 @@ public:
+ 
+     TokenType KeywordType() const
+     {
+-        return keywordType_;
++        return keyword_type_;
+     }
+ 
+     const SourcePosition &Start() const
+     {
+-        return loc_.start;
++        return loc_.start_;
+     }
+ 
+     const SourcePosition &End() const
+     {
+-        return loc_.end;
++        return loc_.end_;
+     }
+ 
+     const SourceRange &Loc() const
+@@ -126,7 +126,7 @@ public:
+ private:
+     friend class KeywordsUtil;
+     TokenType type_ {TokenType::EOS};
+-    TokenType keywordType_ {TokenType::EOS};
++    TokenType keyword_type_ {TokenType::EOS};
+     TokenFlags flags_ {TokenFlags::NONE};
+     SourceRange loc_ {};
+     double number_ {};
+diff --git a/parser/expressionParser.cpp b/parser/expressionParser.cpp
+index f3db9c0..f4f4fac 100644
+--- a/parser/expressionParser.cpp
++++ b/parser/expressionParser.cpp
+@@ -280,7 +280,7 @@ ir::Expression *ParserImpl::ParseArrayExpression(ExpressionParseFlags flags)
+         } else if (!inPattern && lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+             ir::ValidationInfo info = arrayExpressionNode->ValidateExpression();
+             if (info.Fail()) {
+-                ThrowSyntaxError(info.msg.Utf8(), info.pos);
++                ThrowSyntaxError(info.msg_.Utf8(), info.pos_);
+             }
+         }
+     }
+@@ -365,10 +365,10 @@ ir::ArrowFunctionExpression *ParserImpl::ParseArrowFunctionExpressionBody(ArrowF
+                                                                           ir::TSTypeParameterDeclaration *typeParamDecl,
+                                                                           ir::Expression *returnTypeAnnotation)
+ {
+-    context_.Status() |= desc->newStatus;
++    context_.Status() |= desc->new_status_;
+ 
+-    functionScope->BindParamScope(desc->paramScope);
+-    desc->paramScope->BindFunctionScope(functionScope);
++    functionScope->BindParamScope(desc->param_scope_);
++    desc->param_scope_->BindFunctionScope(functionScope);
+ 
+     lexer_->NextToken();  // eat '=>'
+     ir::ScriptFunction *funcNode {};
+@@ -395,11 +395,11 @@ ir::ArrowFunctionExpression *ParserImpl::ParseArrowFunctionExpressionBody(ArrowF
+         endLoc = body->End();
+     }
+ 
+-    funcNode = AllocNode<ir::ScriptFunction>(functionScope, std::move(desc->params), typeParamDecl, body,
++    funcNode = AllocNode<ir::ScriptFunction>(functionScope, std::move(desc->params_), typeParamDecl, body,
+                                              returnTypeAnnotation, arrowFunctionContext->Flags(), false);
+-    funcNode->SetRange({desc->startLoc, endLoc});
++    funcNode->SetRange({desc->start_loc_, endLoc});
+     functionScope->BindNode(funcNode);
+-    desc->paramScope->BindNode(funcNode);
++    desc->param_scope_->BindNode(funcNode);
+ 
+     auto *arrowFuncNode = AllocNode<ir::ArrowFunctionExpression>(funcNode);
+     arrowFuncNode->SetRange(funcNode->Range());
+@@ -672,14 +672,14 @@ void ParserImpl::ValidateParenthesizedExpression(ir::Expression *lhsExpression)
+         case ir::AstNodeType::ARRAY_EXPRESSION: {
+             auto info = lhsExpression->AsArrayExpression()->ValidateExpression();
+             if (info.Fail()) {
+-                ThrowSyntaxError(info.msg.Utf8(), info.pos);
++                ThrowSyntaxError(info.msg_.Utf8(), info.pos_);
+             }
+             break;
+         }
+         case ir::AstNodeType::OBJECT_EXPRESSION: {
+             auto info = lhsExpression->AsObjectExpression()->ValidateExpression();
+             if (info.Fail()) {
+-                ThrowSyntaxError(info.msg.Utf8(), info.pos);
++                ThrowSyntaxError(info.msg_.Utf8(), info.pos_);
+             }
+             break;
+         }
+@@ -829,14 +829,14 @@ ir::TemplateLiteral *ParserImpl::ParseTemplateLiteral()
+         util::StringView cooked = lexer_->GetToken().String();
+ 
+         lexer_->Rewind(startPos);
+-        auto [raw, end, scanExpression] = lexer_->ScanTemplateString();
++        auto [raw, end_, scan_expression_] = lexer_->ScanTemplateString();
+ 
+         auto *element = AllocNode<ir::TemplateElement>(raw.View(), cooked);
+-        element->SetRange({lexer::SourcePosition {startPos.iterator.Index(), startPos.line},
+-                           lexer::SourcePosition {end, lexer_->Line()}});
++        element->SetRange({lexer::SourcePosition {startPos.iterator_.Index(), startPos.line_},
++                           lexer::SourcePosition {end_, lexer_->Line()}});
+         quasis.push_back(element);
+ 
+-        if (!scanExpression) {
++        if (!scan_expression_) {
+             lexer_->ScanTemplateStringEnd();
+             break;
+         }
+@@ -1023,10 +1023,10 @@ ir::Expression *ParserImpl::ParsePrimaryExpression(ExpressionParseFlags flags)
+             try {
+                 reParser.ParsePattern();
+             } catch (lexer::RegExpError &e) {
+-                ThrowSyntaxError(e.message.c_str());
++                ThrowSyntaxError(e.message_.c_str());
+             }
+ 
+-            auto *regexpNode = AllocNode<ir::RegExpLiteral>(regexp.patternStr, regexp.flagsStr);
++            auto *regexpNode = AllocNode<ir::RegExpLiteral>(regexp.pattern_str_, regexp.flags_str_);
+             regexpNode->SetRange(lexer_->GetToken().Loc());
+ 
+             lexer_->NextToken();
+@@ -2151,7 +2151,7 @@ ir::ObjectExpression *ParserImpl::ParseObjectExpression(ExpressionParseFlags fla
+         } else if (!inPattern && lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SUBSTITUTION) {
+             ir::ValidationInfo info = objectExpression->ValidateExpression();
+             if (info.Fail()) {
+-                ThrowSyntaxError(info.msg.Utf8(), info.pos);
++                ThrowSyntaxError(info.msg_.Utf8(), info.pos_);
+             }
+         }
+     }
+diff --git a/parser/parserImpl.cpp b/parser/parserImpl.cpp
+index 87204a4..8048245 100644
+--- a/parser/parserImpl.cpp
++++ b/parser/parserImpl.cpp
+@@ -1747,7 +1747,7 @@ void ParserImpl::ParseClassKeyModifiers(ClassElmentDescriptor *desc)
+         (Extension() == ScriptExtension::TS && nextCp != LEX_CHAR_EQUALS && nextCp != LEX_CHAR_SEMICOLON &&
+          nextCp != LEX_CHAR_LEFT_PAREN)) {
+         if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_GET) {
+-            if (desc->isPrivateIdent) {
++            if (desc->is_private_ident_) {
+                 ThrowSyntaxError("Private identifier can not be getter");
+             }
+ 
+@@ -1755,12 +1755,12 @@ void ParserImpl::ParseClassKeyModifiers(ClassElmentDescriptor *desc)
+                 ThrowSyntaxError("Keyword must not contain escaped characters");
+             }
+ 
+-            desc->methodKind = ir::MethodDefinitionKind::GET;
+-            desc->methodStart = lexer_->GetToken().Start();
++            desc->method_kind_ = ir::MethodDefinitionKind::GET;
++            desc->method_start_ = lexer_->GetToken().Start();
+ 
+             lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+         } else if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_SET) {
+-            if (desc->isPrivateIdent) {
++            if (desc->is_private_ident_) {
+                 ThrowSyntaxError("Private identifier can not be setter");
+             }
+ 
+@@ -1768,8 +1768,8 @@ void ParserImpl::ParseClassKeyModifiers(ClassElmentDescriptor *desc)
+                 ThrowSyntaxError("Keyword must not contain escaped characters");
+             }
+ 
+-            desc->methodKind = ir::MethodDefinitionKind::SET;
+-            desc->methodStart = lexer_->GetToken().Start();
++            desc->method_kind_ = ir::MethodDefinitionKind::SET;
++            desc->method_start_ = lexer_->GetToken().Start();
+ 
+             lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+         }
+@@ -1778,15 +1778,15 @@ void ParserImpl::ParseClassKeyModifiers(ClassElmentDescriptor *desc)
+ 
+ void ParserImpl::ThrowIfPrivateIdent(ClassElmentDescriptor *desc, const char *msg)
+ {
+-    if (desc->isPrivateIdent) {
++    if (desc->is_private_ident_) {
+         ThrowSyntaxError(msg);
+     }
+ }
+ 
+ void ParserImpl::ValidateClassKey(ClassElmentDescriptor *desc)
+ {
+-    if ((desc->modifiers & ir::ModifierFlags::ASYNC) &&
+-        (desc->methodKind == ir::MethodDefinitionKind::GET || desc->methodKind == ir::MethodDefinitionKind::SET)) {
++    if ((desc->modifiers_ & ir::ModifierFlags::ASYNC) &&
++        (desc->method_kind_ == ir::MethodDefinitionKind::GET || desc->method_kind_ == ir::MethodDefinitionKind::SET)) {
+         ThrowSyntaxError("Async method can not be getter nor setter");
+     }
+ 
+@@ -1795,23 +1795,23 @@ void ParserImpl::ValidateClassKey(ClassElmentDescriptor *desc)
+     if (propNameStr.Is("constructor")) {
+         ThrowIfPrivateIdent(desc, "Private identifier can not be constructor");
+ 
+-        if (!(desc->modifiers & ir::ModifierFlags::STATIC)) {
+-            if ((desc->modifiers & ir::ModifierFlags::ASYNC) || desc->methodKind == ir::MethodDefinitionKind::GET ||
+-                desc->methodKind == ir::MethodDefinitionKind::SET || desc->isGenerator) {
++        if (!(desc->modifiers_ & ir::ModifierFlags::STATIC)) {
++            if ((desc->modifiers_ & ir::ModifierFlags::ASYNC) || desc->method_kind_ == ir::MethodDefinitionKind::GET ||
++                desc->method_kind_ == ir::MethodDefinitionKind::SET || desc->is_generator_) {
+                 ThrowSyntaxError("Constructor can not be special method");
+             }
+ 
+-            desc->methodKind = ir::MethodDefinitionKind::CONSTRUCTOR;
+-            desc->methodStart = lexer_->GetToken().Start();
+-            desc->newStatus |= ParserStatus::CONSTRUCTOR_FUNCTION;
++            desc->method_kind_ = ir::MethodDefinitionKind::CONSTRUCTOR;
++            desc->method_start_ = lexer_->GetToken().Start();
++            desc->new_status_ |= ParserStatus::CONSTRUCTOR_FUNCTION;
+ 
+-            if (desc->hasSuperClass) {
+-                desc->newStatus |= ParserStatus::ALLOW_SUPER_CALL;
++            if (desc->has_super_class_) {
++                desc->new_status_ |= ParserStatus::ALLOW_SUPER_CALL;
+             }
+         } else if (Extension() == ScriptExtension::TS) {
+             ThrowSyntaxError("Static modifier can not appear on a constructor");
+         }
+-    } else if (propNameStr.Is("prototype") && (desc->modifiers & ir::ModifierFlags::STATIC)) {
++    } else if (propNameStr.Is("prototype") && (desc->modifiers_ & ir::ModifierFlags::STATIC)) {
+         ThrowSyntaxError("Classes may not have static property named prototype");
+     }
+ }
+@@ -1857,7 +1857,7 @@ ir::Expression *ParserImpl::ParseClassKey(ClassElmentDescriptor *desc)
+ 
+             if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::LITERAL_IDENT &&
+                 lexer_->Lookahead() == LEX_CHAR_COLON) {
+-                desc->isIndexSignature = true;
++                desc->is_index_signature_ = true;
+ 
+                 propName = AllocNode<ir::Identifier>(lexer_->GetToken().Ident(), Allocator());
+                 propName->SetRange(lexer_->GetToken().Loc());
+@@ -1889,12 +1889,12 @@ ir::Expression *ParserImpl::ParseClassKey(ClassElmentDescriptor *desc)
+                 return propName;
+             }
+ 
+-            desc->isComputed = true;
++            desc->is_computed_ = true;
+ 
+             propName = ParseExpression(ExpressionParseFlags::ACCEPT_COMMA);
+ 
+             if (Extension() == ScriptExtension::TS) {
+-                desc->invalidComputedProperty =
++                desc->invalid_computed_property_ =
+                     !propName->IsNumberLiteral() && !propName->IsStringLiteral() &&
+                     !(propName->IsMemberExpression() && propName->AsMemberExpression()->Object()->IsIdentifier() &&
+                       propName->AsMemberExpression()->Object()->AsIdentifier()->Name().Is("Symbol"));
+@@ -1921,28 +1921,28 @@ void ParserImpl::ValidateClassMethodStart(ClassElmentDescriptor *desc, ir::Expre
+         if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS) {
+             return;
+         }
+-        desc->classMethod = true;
++        desc->class_method_ = true;
+     }
+ 
+     if (Extension() == ScriptExtension::TS &&
+-        lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS && desc->isPrivateIdent) {
++        lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS && desc->is_private_ident_) {
+         ThrowSyntaxError("A method cannot be named with a private identifier");
+     }
+ 
+     if (Extension() == ScriptExtension::TS) {
+         if (!typeAnnotation && (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_PARENTHESIS ||
+                                 lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LESS_THAN)) {
+-            if ((desc->modifiers & (ir::ModifierFlags::DECLARE | ir::ModifierFlags::READONLY))) {
++            if ((desc->modifiers_ & (ir::ModifierFlags::DECLARE | ir::ModifierFlags::READONLY))) {
+                 ThrowSyntaxError("Class method can not be declare nor readonly");
+             }
+-            desc->classMethod = true;
++            desc->class_method_ = true;
+         } else {
+-            if ((desc->modifiers & ir::ModifierFlags::ASYNC) || desc->isGenerator) {
++            if ((desc->modifiers_ & ir::ModifierFlags::ASYNC) || desc->is_generator_) {
+                 ThrowSyntaxError("Expected '('");
+             }
+-            desc->classField = true;
++            desc->class_field_ = true;
+ 
+-            if (desc->invalidComputedProperty) {
++            if (desc->invalid_computed_property_) {
+                 ThrowSyntaxError(
+                     "Computed property name must refer to a symbol or "
+                     "literal expression whos value is "
+@@ -1951,12 +1951,12 @@ void ParserImpl::ValidateClassMethodStart(ClassElmentDescriptor *desc, ir::Expre
+         }
+     }
+ 
+-    if (desc->modifiers & ir::ModifierFlags::ASYNC) {
+-        desc->newStatus |= ParserStatus::ASYNC_FUNCTION;
++    if (desc->modifiers_ & ir::ModifierFlags::ASYNC) {
++        desc->new_status_ |= ParserStatus::ASYNC_FUNCTION;
+     }
+ 
+-    if (desc->isGenerator) {
+-        desc->newStatus |= ParserStatus::GENERATOR_FUNCTION;
++    if (desc->is_generator_) {
++        desc->new_status_ |= ParserStatus::GENERATOR_FUNCTION;
+     }
+ }
+ 
+@@ -1968,8 +1968,8 @@ void ParserImpl::ValidateClassSetter(ClassElmentDescriptor *desc, const ArenaVec
+         ThrowSyntaxError("Setter must have exactly one formal parameter");
+     }
+ 
+-    if (Extension() == ScriptExtension::TS && !(desc->modifiers & ir::ModifierFlags::STATIC)) {
+-        ir::ModifierFlags access = GetAccessability(desc->modifiers);
++    if (Extension() == ScriptExtension::TS && !(desc->modifiers_ & ir::ModifierFlags::STATIC)) {
++        ir::ModifierFlags access = GetAccessability(desc->modifiers_);
+         CheckAccessorPair(properties, propName, ir::MethodDefinitionKind::GET, access, hasDecorator, errorInfo);
+     }
+ }
+@@ -1982,8 +1982,8 @@ void ParserImpl::ValidateClassGetter(ClassElmentDescriptor *desc, const ArenaVec
+         ThrowSyntaxError("Getter must not have formal parameters");
+     }
+ 
+-    if (Extension() == ScriptExtension::TS && !(desc->modifiers & ir::ModifierFlags::STATIC)) {
+-        ir::ModifierFlags access = GetAccessability(desc->modifiers);
++    if (Extension() == ScriptExtension::TS && !(desc->modifiers_ & ir::ModifierFlags::STATIC)) {
++        ir::ModifierFlags access = GetAccessability(desc->modifiers_);
+ 
+         CheckAccessorPair(properties, propName, ir::MethodDefinitionKind::SET, access, hasDecorator, errorInfo);
+     }
+@@ -1995,22 +1995,23 @@ ir::MethodDefinition *ParserImpl::ParseClassMethod(ClassElmentDescriptor *desc,
+                                                    ArenaVector<ir::Decorator *> &&decorators, bool isDeclare)
+ {
+     if (Extension() == ScriptExtension::TS) {
+-        if (desc->methodKind == ir::MethodDefinitionKind::SET || desc->methodKind == ir::MethodDefinitionKind::GET) {
+-            desc->newStatus |= ParserStatus::ACCESSOR_FUNCTION;
++        if (desc->method_kind_ == ir::MethodDefinitionKind::SET ||
++            desc->method_kind_ == ir::MethodDefinitionKind::GET) {
++            desc->new_status_ |= ParserStatus::ACCESSOR_FUNCTION;
+         }
+ 
+-        desc->newStatus |= ParserStatus::IN_METHOD_DEFINITION;
++        desc->new_status_ |= ParserStatus::IN_METHOD_DEFINITION;
+     }
+ 
+-    if (isDeclare && (desc->newStatus & ParserStatus::ASYNC_FUNCTION)) {
++    if (isDeclare && (desc->new_status_ & ParserStatus::ASYNC_FUNCTION)) {
+         ThrowSyntaxError("'async' modifier cannot be used in an ambient context.");
+     }
+ 
+-    if (isDeclare && desc->isGenerator) {
++    if (isDeclare && desc->is_generator_) {
+         ThrowSyntaxError("Generators are not allowed in an ambient context.");
+     }
+ 
+-    ir::ScriptFunction *func = ParseFunction(desc->newStatus, isDeclare);
++    ir::ScriptFunction *func = ParseFunction(desc->new_status_, isDeclare);
+ 
+     if (func->IsOverload() && !decorators.empty()) {
+         ThrowSyntaxError("A decorator can only decorate a method implementation, not an overload.",
+@@ -2022,16 +2023,16 @@ ir::MethodDefinition *ParserImpl::ParseClassMethod(ClassElmentDescriptor *desc,
+ 
+     lexer::SourcePosition errorInfo = decorators.empty() ? func->Start() : decorators[0]->Start();
+ 
+-    if (desc->methodKind == ir::MethodDefinitionKind::SET) {
++    if (desc->method_kind_ == ir::MethodDefinitionKind::SET) {
+         ValidateClassSetter(desc, properties, propName, func, !decorators.empty(), errorInfo);
+-    } else if (desc->methodKind == ir::MethodDefinitionKind::GET) {
++    } else if (desc->method_kind_ == ir::MethodDefinitionKind::GET) {
+         ValidateClassGetter(desc, properties, propName, func, !decorators.empty(), errorInfo);
+     }
+ 
+     *propEnd = func->End();
+     func->AddFlag(ir::ScriptFunctionFlags::METHOD);
+-    auto *method = AllocNode<ir::MethodDefinition>(desc->methodKind, propName, funcExpr, desc->modifiers, Allocator(),
+-                                                   std::move(decorators), desc->isComputed);
++    auto *method = AllocNode<ir::MethodDefinition>(desc->method_kind_, propName, funcExpr, desc->modifiers_,
++                                                   Allocator(), std::move(decorators), desc->is_computed_);
+     method->SetRange(funcExpr->Range());
+     return method;
+ }
+@@ -2044,9 +2045,9 @@ ir::Statement *ParserImpl::ParseClassProperty(ClassElmentDescriptor *desc,
+     lexer::SourcePosition propEnd = propName->End();
+     ir::Statement *property = nullptr;
+ 
+-    if (desc->classMethod) {
++    if (desc->class_method_) {
+         property = ParseClassMethod(desc, properties, propName, &propEnd, std::move(decorators), isDeclare);
+-        property->SetRange({desc->propStart, propEnd});
++        property->SetRange({desc->prop_start_, propEnd});
+         return property;
+     }
+ 
+@@ -2065,21 +2066,21 @@ ir::Statement *ParserImpl::ParseClassProperty(ClassElmentDescriptor *desc,
+     ir::Expression *privateId = nullptr;
+ 
+     if (Extension() == ScriptExtension::JS) {
+-        if (desc->isPrivateIdent) {
++        if (desc->is_private_ident_) {
+             ThrowSyntaxError("Private js fields are not supported");
+         }
+     } else {
+-        if (desc->isPrivateIdent) {
++        if (desc->is_private_ident_) {
+             privateId = AllocNode<ir::TSPrivateIdentifier>(propName, value, typeAnnotation);
+-            privateId->SetRange({desc->propStart, propName->End()});
++            privateId->SetRange({desc->prop_start_, propName->End()});
+         }
+     }
+ 
+-    property = AllocNode<ir::ClassProperty>(desc->isPrivateIdent ? privateId : propName, value, typeAnnotation,
+-                                            desc->modifiers, std::move(decorators), desc->isComputed,
+-                                            desc->modifiers & ir::ModifierFlags::DEFINITE);
++    property = AllocNode<ir::ClassProperty>(desc->is_private_ident_ ? privateId : propName, value, typeAnnotation,
++                                            desc->modifiers_, std::move(decorators), desc->is_computed_,
++                                            desc->modifiers_ & ir::ModifierFlags::DEFINITE);
+ 
+-    property->SetRange({desc->propStart, propEnd});
++    property->SetRange({desc->prop_start_, propEnd});
+     return property;
+ }
+ 
+@@ -2091,7 +2092,7 @@ void ParserImpl::CheckClassGeneratorMethod(ClassElmentDescriptor *desc)
+ 
+     ThrowIfPrivateIdent(desc, "Unexpected character in private identifier");
+ 
+-    desc->isGenerator = true;
++    desc->is_generator_ = true;
+     lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+ }
+ 
+@@ -2109,11 +2110,11 @@ void ParserImpl::CheckClassPrivateIdentifier(ClassElmentDescriptor *desc)
+         return;
+     }
+ 
+-    if (desc->modifiers != ir::ModifierFlags::NONE) {
++    if (desc->modifiers_ != ir::ModifierFlags::NONE) {
+         ThrowSyntaxError("Unexpected modifier on private identifier");
+     }
+ 
+-    desc->isPrivateIdent = true;
++    desc->is_private_ident_ = true;
+     lexer_->NextToken(lexer::LexerNextTokenFlags::KEYWORD_TO_IDENT);
+ }
+ 
+@@ -2171,16 +2172,16 @@ ir::Statement *ParserImpl::ParseClassElement(const ArenaVector<ir::Statement *>
+ {
+     ClassElmentDescriptor desc;
+ 
+-    desc.methodKind = ir::MethodDefinitionKind::METHOD;
+-    desc.newStatus = ParserStatus::ALLOW_SUPER;
+-    desc.hasSuperClass = hasSuperClass;
+-    desc.propStart = lexer_->GetToken().Start();
++    desc.method_kind_ = ir::MethodDefinitionKind::METHOD;
++    desc.new_status_ = ParserStatus::ALLOW_SUPER;
++    desc.has_super_class_ = hasSuperClass;
++    desc.prop_start_ = lexer_->GetToken().Start();
+ 
+     auto decorators = ParseDecorators();
+ 
+-    desc.modifiers = ParseModifiers();
++    desc.modifiers_ = ParseModifiers();
+ 
+-    if ((desc.modifiers & ir::ModifierFlags::ABSTRACT) && !isAbstractClass) {
++    if ((desc.modifiers_ & ir::ModifierFlags::ABSTRACT) && !isAbstractClass) {
+         ThrowSyntaxError("Abstract methods can only appear within an abstract class.");
+     }
+ 
+@@ -2188,41 +2189,41 @@ ir::Statement *ParserImpl::ParseClassElement(const ArenaVector<ir::Statement *>
+     CheckClassGeneratorMethod(&desc);
+     ParseClassKeyModifiers(&desc);
+ 
+-    if (!(desc.modifiers & ir::ModifierFlags::STATIC)) {
++    if (!(desc.modifiers_ & ir::ModifierFlags::STATIC)) {
+         context_.Status() |= ParserStatus::ALLOW_THIS_TYPE;
+     }
+ 
+     ir::Expression *propName = ParseClassKey(&desc);
+ 
+-    if (desc.methodKind == ir::MethodDefinitionKind::CONSTRUCTOR && !decorators.empty()) {
++    if (desc.method_kind_ == ir::MethodDefinitionKind::CONSTRUCTOR && !decorators.empty()) {
+         ThrowSyntaxError("Decorators are not valid here.", decorators.front()->Start());
+     }
+ 
+     if (Extension() == ScriptExtension::TS && lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_QUESTION_MARK) {
+-        if (desc.isIndexSignature) {
++        if (desc.is_index_signature_) {
+             ThrowSyntaxError("';' expected");
+         }
+ 
+-        if (desc.methodKind == ir::MethodDefinitionKind::CONSTRUCTOR) {
++        if (desc.method_kind_ == ir::MethodDefinitionKind::CONSTRUCTOR) {
+             ThrowSyntaxError("'(' expected");
+         }
+ 
+-        desc.modifiers |= ir::ModifierFlags::OPTIONAL;
++        desc.modifiers_ |= ir::ModifierFlags::OPTIONAL;
+         lexer_->NextToken();
+     } else if (Extension() == ScriptExtension::TS &&
+                lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_EXCLAMATION_MARK) {
+-        if (desc.isIndexSignature || lexer_->Lookahead() != LEX_CHAR_COLON) {
++        if (desc.is_index_signature_ || lexer_->Lookahead() != LEX_CHAR_COLON) {
+             ThrowSyntaxError("';' expected");
+         }
+ 
+-        desc.modifiers |= ir::ModifierFlags::DEFINITE;
++        desc.modifiers_ |= ir::ModifierFlags::DEFINITE;
+         lexer_->NextToken();
+     }
+ 
+     ir::Expression *typeAnnotation = ParseClassKeyAnnotation();
+ 
+     ir::Statement *property = nullptr;
+-    if (desc.isIndexSignature) {
++    if (desc.is_index_signature_) {
+         if (!decorators.empty()) {
+             ThrowSyntaxError("Decorators are not valid here.", decorators.front()->Start());
+         }
+@@ -2232,7 +2233,7 @@ ir::Statement *ParserImpl::ParseClassElement(const ArenaVector<ir::Statement *>
+         }
+ 
+         auto *indexSignature =
+-            AllocNode<ir::TSIndexSignature>(propName, typeAnnotation, desc.modifiers & ir::ModifierFlags::READONLY);
++            AllocNode<ir::TSIndexSignature>(propName, typeAnnotation, desc.modifiers_ & ir::ModifierFlags::READONLY);
+ 
+         indexSignature->SetRange({indexSignature->Param()->Start(), indexSignature->TypeAnnotation()->End()});
+ 
+@@ -2242,7 +2243,7 @@ ir::Statement *ParserImpl::ParseClassElement(const ArenaVector<ir::Statement *>
+     } else {
+         ValidateClassMethodStart(&desc, typeAnnotation);
+         property = ParseClassProperty(&desc, properties, propName, typeAnnotation, std::move(decorators),
+-                                      isDeclare || (desc.modifiers & ir::ModifierFlags::DECLARE));
++                                      isDeclare || (desc.modifiers_ & ir::ModifierFlags::DECLARE));
+     }
+ 
+     if (lexer_->GetToken().Type() != lexer::TokenType::PUNCTUATOR_SEMI_COLON &&
+@@ -3244,7 +3245,7 @@ void ParserImpl::ThrowSyntaxError(std::string_view errorMessage, const lexer::So
+     lexer::LineIndex index(program_.SourceCode());
+     lexer::SourceLocation loc = index.GetLocation(pos);
+ 
+-    throw Error {ErrorType::SYNTAX, errorMessage, loc.line, loc.col};
++    throw Error {ErrorType::SYNTAX, errorMessage, loc.line_, loc.col_};
+ }
+ 
+ ScriptExtension ParserImpl::Extension() const
+@@ -3264,7 +3265,7 @@ void ExportDeclarationContext::BindExportDecl(const ir::AstNode *exportDecl)
+         const auto *decl = exportDecl->AsExportDefaultDeclaration();
+         const auto *rhs = decl->Decl();
+ 
+-        if (binder_->GetScope()->Bindings().size() == savedBindings_.size()) {
++        if (binder_->GetScope()->Bindings().size() == saved_bindings_.size()) {
+             if (rhs->IsFunctionDeclaration()) {
+                 binder_->AddDecl<binder::FunctionDecl>(rhs->Start(), binder_->Allocator(),
+                                                        util::StringView(DEFAULT_EXPORT),
+@@ -3276,7 +3277,7 @@ void ExportDeclarationContext::BindExportDecl(const ir::AstNode *exportDecl)
+     }
+ 
+     for (const auto &[name, variable] : binder_->GetScope()->Bindings()) {
+-        if (savedBindings_.find(name) != savedBindings_.end()) {
++        if (saved_bindings_.find(name) != saved_bindings_.end()) {
+             continue;
+         }
+ 
+@@ -3296,7 +3297,7 @@ void ImportDeclarationContext::BindImportDecl(const ir::ImportDeclaration *impor
+     binder::ModuleScope::ImportDeclList declList(Allocator()->Adapter());
+ 
+     for (const auto &[name, variable] : binder_->GetScope()->Bindings()) {
+-        if (savedBindings_.find(name) != savedBindings_.end()) {
++        if (saved_bindings_.find(name) != saved_bindings_.end()) {
+             continue;
+         }
+ 
+diff --git a/parser/parserImpl.h b/parser/parserImpl.h
+index 2d8f1fa..14928f5 100644
+--- a/parser/parserImpl.h
++++ b/parser/parserImpl.h
+@@ -124,33 +124,33 @@ class ParserContext;
+ 
+ class ClassElmentDescriptor {
+ public:
+-    ir::MethodDefinitionKind methodKind {};
+-    ParserStatus newStatus {};
+-    ir::ModifierFlags modifiers {};
+-    lexer::SourcePosition methodStart {};
+-    lexer::SourcePosition propStart {};
+-    bool isPrivateIdent {};
+-    bool hasSuperClass {};
+-    bool isGenerator {};
+-    bool invalidComputedProperty {};
+-    bool isComputed {};
+-    bool isIndexSignature {};
+-    bool classMethod {};
+-    bool classField {};
++    ir::MethodDefinitionKind method_kind_ {};
++    ParserStatus new_status_ {};
++    ir::ModifierFlags modifiers_ {};
++    lexer::SourcePosition method_start_ {};
++    lexer::SourcePosition prop_start_ {};
++    bool is_private_ident_ {};
++    bool has_super_class_ {};
++    bool is_generator_ {};
++    bool invalid_computed_property_ {};
++    bool is_computed_ {};
++    bool is_index_signature_ {};
++    bool class_method_ {};
++    bool class_field_ {};
+ };
+ 
+ class ArrowFunctionDescriptor {
+ public:
+     explicit ArrowFunctionDescriptor(ArenaVector<ir::Expression *> &&p, binder::FunctionParamScope *ps,
+                                      lexer::SourcePosition sl, ParserStatus ns)
+-        : params(p), paramScope(ps), startLoc(sl), newStatus(ns)
++        : params_(p), param_scope_(ps), start_loc_(sl), new_status_(ns)
+     {
+     }
+ 
+-    ArenaVector<ir::Expression *> params;
+-    binder::FunctionParamScope *paramScope;
+-    lexer::SourcePosition startLoc;
+-    ParserStatus newStatus;
++    ArenaVector<ir::Expression *> params_;
++    binder::FunctionParamScope *param_scope_;
++    lexer::SourcePosition start_loc_;
++    ParserStatus new_status_;
+ };
+ 
+ enum class TypeAnnotationParsingOptions {
+@@ -482,7 +482,7 @@ class SavedStatusContext {
+ public:
+     explicit SavedStatusContext(ParserContext *ctx)
+         // NOLINTNEXTLINE(readability-magic-numbers)
+-        : ctx_(ctx), savedStatus_(static_cast<ParserStatus>(ctx->Status() & status))
++        : ctx_(ctx), saved_status_(static_cast<ParserStatus>(ctx->Status() & status))
+     {
+         // NOLINTNEXTLINE(readability-magic-numbers)
+         ctx->Status() |= status;
+@@ -493,14 +493,14 @@ public:
+ 
+     ~SavedStatusContext()
+     {
+-        if (savedStatus_ == ParserStatus::NO_OPTS) {
+-            ctx_->Status() &= ~savedStatus_;
++        if (saved_status_ == ParserStatus::NO_OPTS) {
++            ctx_->Status() &= ~saved_status_;
+         }
+     }
+ 
+ private:
+     ParserContext *ctx_;
+-    ParserStatus savedStatus_;
++    ParserStatus saved_status_;
+ };
+ 
+ class SwitchContext : public SavedStatusContext<ParserStatus::IN_SWITCH> {
+@@ -515,7 +515,7 @@ template <typename T>
+ class IterationContext : public SavedStatusContext<ParserStatus::IN_ITERATION> {
+ public:
+     explicit IterationContext(ParserContext *ctx, binder::Binder *binder)
+-        : SavedStatusContext(ctx), lexicalScope_(binder)
++        : SavedStatusContext(ctx), lexical_scope_(binder)
+     {
+     }
+ 
+@@ -525,23 +525,23 @@ public:
+ 
+     const auto &LexicalScope() const
+     {
+-        return lexicalScope_;
++        return lexical_scope_;
+     }
+ 
+ private:
+-    binder::LexicalScope<T> lexicalScope_;
++    binder::LexicalScope<T> lexical_scope_;
+ };
+ 
+ class FunctionParameterContext : public SavedStatusContext<ParserStatus::FUNCTION_PARAM> {
+ public:
+     explicit FunctionParameterContext(ParserContext *ctx, binder::Binder *binder)
+-        : SavedStatusContext(ctx), lexicalScope_(binder)
++        : SavedStatusContext(ctx), lexical_scope_(binder)
+     {
+     }
+ 
+     const auto &LexicalScope() const
+     {
+-        return lexicalScope_;
++        return lexical_scope_;
+     }
+ 
+     NO_COPY_SEMANTIC(FunctionParameterContext);
+@@ -549,7 +549,7 @@ public:
+     ~FunctionParameterContext() = default;
+ 
+ private:
+-    binder::LexicalScope<binder::FunctionParamScope> lexicalScope_;
++    binder::LexicalScope<binder::FunctionParamScope> lexical_scope_;
+ };
+ 
+ class SavedParserContext {
+@@ -640,7 +640,7 @@ private:
+ class SavedBindingsContext {
+ public:
+     explicit SavedBindingsContext(binder::Binder *binder)
+-        : binder_(binder), savedBindings_(binder_->GetScope()->Bindings())
++        : binder_(binder), saved_bindings_(binder_->GetScope()->Bindings())
+     {
+     }
+     NO_COPY_SEMANTIC(SavedBindingsContext);
+@@ -654,7 +654,7 @@ protected:
+     }
+ 
+     binder::Binder *binder_;
+-    binder::VariableMap savedBindings_;
++    binder::VariableMap saved_bindings_;
+ };
+ 
+ class ExportDeclarationContext : public SavedBindingsContext {
+diff --git a/parser/program/program.cpp b/parser/program/program.cpp
+index 42bee03..95775a9 100644
+--- a/parser/program/program.cpp
++++ b/parser/program/program.cpp
+@@ -23,8 +23,8 @@ namespace panda::es2panda::parser {
+ Program::Program(ScriptExtension extension)
+     : allocator_(std::make_unique<ArenaAllocator>(SpaceType::SPACE_TYPE_COMPILER, nullptr, true)),
+       binder_(allocator_->New<binder::Binder>(this)),
+-      sourceCode_(Allocator()),
+-      sourceFile_(Allocator()),
++      source_code_(Allocator()),
++      source_file_(Allocator()),
+       extension_(extension)
+ {
+ }
+@@ -33,8 +33,8 @@ Program::Program(Program &&other)
+     : allocator_(std::move(other.allocator_)),
+       binder_(other.binder_),
+       ast_(other.ast_),
+-      sourceCode_(other.sourceCode_),
+-      sourceFile_(other.sourceFile_),
++      source_code_(other.source_code_),
++      source_file_(other.source_file_),
+       kind_(other.kind_),
+       extension_(other.extension_)
+ {
+@@ -47,8 +47,8 @@ Program &Program::operator=(Program &&other)
+     allocator_ = std::move(other.allocator_);
+     binder_ = other.binder_;
+     ast_ = other.ast_;
+-    sourceCode_ = other.sourceCode_;
+-    sourceFile_ = other.sourceFile_;
++    source_code_ = other.source_code_;
++    source_file_ = other.source_file_;
+     kind_ = other.kind_;
+     extension_ = other.extension_;
+ 
+diff --git a/parser/program/program.h b/parser/program/program.h
+index 75f399e..7f23d47 100644
+--- a/parser/program/program.h
++++ b/parser/program/program.h
+@@ -69,12 +69,12 @@ public:
+ 
+     util::StringView SourceCode() const
+     {
+-        return sourceCode_.View();
++        return source_code_.View();
+     }
+ 
+     util::StringView SourceFile() const
+     {
+-        return sourceFile_.View();
++        return source_file_.View();
+     }
+ 
+     ir::BlockStatement *Ast()
+@@ -94,8 +94,8 @@ public:
+ 
+     void SetSource(const std::string &sourceCode, const std::string &sourceFile)
+     {
+-        sourceCode_ = util::UString(sourceCode, Allocator());
+-        sourceFile_ = util::UString(sourceFile, Allocator());
++        source_code_ = util::UString(sourceCode, Allocator());
++        source_file_ = util::UString(sourceFile, Allocator());
+     }
+ 
+     std::string Dump() const;
+@@ -105,8 +105,8 @@ private:
+     std::unique_ptr<ArenaAllocator> allocator_ {};
+     binder::Binder *binder_ {};
+     ir::BlockStatement *ast_ {};
+-    util::UString sourceCode_ {};
+-    util::UString sourceFile_ {};
++    util::UString source_code_ {};
++    util::UString source_file_ {};
+     ScriptKind kind_ {};
+     ScriptExtension extension_ {};
+ };
+diff --git a/parser/statementParser.cpp b/parser/statementParser.cpp
+index 2a06a84..cba69db 100644
+--- a/parser/statementParser.cpp
++++ b/parser/statementParser.cpp
+@@ -1023,7 +1023,7 @@ ir::Statement *ParserImpl::ParseExpressionStatement(StatementParsingFlags flags)
+             }
+ 
+             ir::FunctionDeclaration *functionDecl = ParseFunctionDeclaration(false, ParserStatus::ASYNC_FUNCTION);
+-            functionDecl->SetStart(startPos.token.Start());
++            functionDecl->SetStart(startPos.token_.Start());
+ 
+             return functionDecl;
+         }
+@@ -1036,7 +1036,7 @@ ir::Statement *ParserImpl::ParseExpressionStatement(StatementParsingFlags flags)
+     lexer::SourcePosition endPos = exprNode->End();
+ 
+     auto *exprStatementNode = AllocNode<ir::ExpressionStatement>(exprNode);
+-    exprStatementNode->SetRange({startPos.token.Start(), endPos});
++    exprStatementNode->SetRange({startPos.token_.Start(), endPos});
+     ConsumeSemicolon(exprStatementNode);
+ 
+     return exprStatementNode;
+@@ -1363,28 +1363,28 @@ ir::IfStatement *ParserImpl::ParseIfStatement()
+ 
+ ir::LabelledStatement *ParserImpl::ParseLabelledStatement(const lexer::LexerPosition &pos)
+ {
+-    const util::StringView &actualLabel = pos.token.Ident();
++    const util::StringView &actualLabel = pos.token_.Ident();
+ 
+     // TODO(frobert) : check correctness
+     if (lexer_->GetToken().KeywordType() == lexer::TokenType::KEYW_AWAIT && context_.IsModule()) {
+-        ThrowSyntaxError("'await' is a reserved identifier in module code", pos.token.Start());
++        ThrowSyntaxError("'await' is a reserved identifier in module code", pos.token_.Start());
+     }
+ 
+     if (context_.FindLabel(actualLabel)) {
+-        ThrowSyntaxError("Label already declared", pos.token.Start());
++        ThrowSyntaxError("Label already declared", pos.token_.Start());
+     }
+ 
+     SavedParserContext newCtx(this, ParserStatus::IN_LABELED, actualLabel);
+ 
+     auto *identNode = AllocNode<ir::Identifier>(actualLabel, Allocator());
+-    identNode->SetRange(pos.token.Loc());
++    identNode->SetRange(pos.token_.Loc());
+ 
+     lexer_->NextToken();
+ 
+     ir::Statement *body = ParseStatement(StatementParsingFlags::LABELLED);
+ 
+     auto *labeledStatement = AllocNode<ir::LabelledStatement>(identNode, body);
+-    labeledStatement->SetRange({pos.token.Start(), body->End()});
++    labeledStatement->SetRange({pos.token_.Start(), body->End()});
+ 
+     return labeledStatement;
+ }
+diff --git a/typescript/checker.cpp b/typescript/checker.cpp
+index 71be1ad..dce4613 100644
+--- a/typescript/checker.cpp
++++ b/typescript/checker.cpp
+@@ -33,19 +33,19 @@ namespace panda::es2panda::checker {
+ Checker::Checker(ArenaAllocator *allocator, binder::Binder *binder)
+     : allocator_(allocator),
+       binder_(binder),
+-      rootNode_(binder->TopScope()->Node()->AsBlockStatement()),
++      root_node_(binder->TopScope()->Node()->AsBlockStatement()),
+       scope_(binder->TopScope())
+ {
+-    scopeStack_.push_back(scope_);
+-    globalTypes_ = allocator_->New<GlobalTypesHolder>(allocator_);
++    scope_stack_.push_back(scope_);
++    global_types_ = allocator_->New<GlobalTypesHolder>(allocator_);
+     relation_ = allocator_->New<TypeRelation>(this);
+     status_ = CheckerStatus::NO_OPTS;
+ }
+ 
+ void Checker::StartChecker()
+ {
+-    ASSERT(rootNode_->IsProgram());
+-    rootNode_->Check(this);
++    ASSERT(root_node_->IsProgram());
++    root_node_->Check(this);
+ }
+ 
+ binder::Scope *Checker::Scope() const
+@@ -84,127 +84,127 @@ void Checker::ThrowTypeError(std::string_view message, const lexer::SourcePositi
+     lexer::LineIndex index(binder_->Program()->SourceCode());
+     lexer::SourceLocation loc = index.GetLocation(pos);
+ 
+-    throw Error {ErrorType::TYPE, message, loc.line, loc.col};
++    throw Error {ErrorType::TYPE, message, loc.line_, loc.col_};
+ }
+ 
+ Type *Checker::GlobalNumberType()
+ {
+-    return globalTypes_->GlobalNumberType();
++    return global_types_->GlobalNumberType();
+ }
+ 
+ Type *Checker::GlobalAnyType()
+ {
+-    return globalTypes_->GlobalAnyType();
++    return global_types_->GlobalAnyType();
+ }
+ 
+ Type *Checker::GlobalStringType()
+ {
+-    return globalTypes_->GlobalStringType();
++    return global_types_->GlobalStringType();
+ }
+ 
+ Type *Checker::GlobalBooleanType()
+ {
+-    return globalTypes_->GlobalBooleanType();
++    return global_types_->GlobalBooleanType();
+ }
+ 
+ Type *Checker::GlobalVoidType()
+ {
+-    return globalTypes_->GlobalVoidType();
++    return global_types_->GlobalVoidType();
+ }
+ 
+ Type *Checker::GlobalNullType()
+ {
+-    return globalTypes_->GlobalNullType();
++    return global_types_->GlobalNullType();
+ }
+ 
+ Type *Checker::GlobalUndefinedType()
+ {
+-    return globalTypes_->GlobalUndefinedType();
++    return global_types_->GlobalUndefinedType();
+ }
+ 
+ Type *Checker::GlobalUnknownType()
+ {
+-    return globalTypes_->GlobalUnknownType();
++    return global_types_->GlobalUnknownType();
+ }
+ 
+ Type *Checker::GlobalNeverType()
+ {
+-    return globalTypes_->GlobalNeverType();
++    return global_types_->GlobalNeverType();
+ }
+ 
+ Type *Checker::GlobalNonPrimitiveType()
+ {
+-    return globalTypes_->GlobalNonPrimitiveType();
++    return global_types_->GlobalNonPrimitiveType();
+ }
+ 
+ Type *Checker::GlobalBigintType()
+ {
+-    return globalTypes_->GlobalBigintType();
++    return global_types_->GlobalBigintType();
+ }
+ 
+ Type *Checker::GlobalFalseType()
+ {
+-    return globalTypes_->GlobalFalseType();
++    return global_types_->GlobalFalseType();
+ }
+ 
+ Type *Checker::GlobalTrueType()
+ {
+-    return globalTypes_->GlobalTrueType();
++    return global_types_->GlobalTrueType();
+ }
+ 
+ Type *Checker::GlobalNumberOrBigintType()
+ {
+-    return globalTypes_->GlobalNumberOrBigintType();
++    return global_types_->GlobalNumberOrBigintType();
+ }
+ 
+ Type *Checker::GlobalStringOrNumberType()
+ {
+-    return globalTypes_->GlobalStringOrNumberType();
++    return global_types_->GlobalStringOrNumberType();
+ }
+ 
+ Type *Checker::GlobalZeroType()
+ {
+-    return globalTypes_->GlobalZeroType();
++    return global_types_->GlobalZeroType();
+ }
+ 
+ Type *Checker::GlobalEmptyStringType()
+ {
+-    return globalTypes_->GlobalEmptyStringType();
++    return global_types_->GlobalEmptyStringType();
+ }
+ 
+ Type *Checker::GlobalZeroBigintType()
+ {
+-    return globalTypes_->GlobalZeroBigintType();
++    return global_types_->GlobalZeroBigintType();
+ }
+ 
+ Type *Checker::GlobalPrimitiveType()
+ {
+-    return globalTypes_->GlobalPrimitiveType();
++    return global_types_->GlobalPrimitiveType();
+ }
+ 
+ Type *Checker::GlobalEmptyTupleType()
+ {
+-    return globalTypes_->GlobalEmptyTupleType();
++    return global_types_->GlobalEmptyTupleType();
+ }
+ 
+ Type *Checker::GlobalEmptyObjectType()
+ {
+-    return globalTypes_->GlobalEmptyObjectType();
++    return global_types_->GlobalEmptyObjectType();
+ }
+ 
+ NumberLiteralPool &Checker::NumberLiteralMap()
+ {
+-    return numberLiteralMap_;
++    return number_literal_map_;
+ }
+ 
+ StringLiteralPool &Checker::StringLiteralMap()
+ {
+-    return stringLiteralMap_;
++    return string_literal_map_;
+ }
+ 
+ StringLiteralPool &Checker::BigintLiteralMap()
+ {
+-    return bigintLiteralMap_;
++    return bigint_literal_map_;
+ }
+ 
+ TypeRelation *Checker::Relation()
+@@ -214,27 +214,27 @@ TypeRelation *Checker::Relation()
+ 
+ RelationHolder &Checker::IdenticalResults()
+ {
+-    return identicalResults_;
++    return identical_results_;
+ }
+ 
+ RelationHolder &Checker::AssignableResults()
+ {
+-    return assignableResults_;
++    return assignable_results_;
+ }
+ 
+ RelationHolder &Checker::ComparableResults()
+ {
+-    return comparableResults_;
++    return comparable_results_;
+ }
+ 
+ std::unordered_set<const ir::AstNode *> &Checker::TypeStack()
+ {
+-    return typeStack_;
++    return type_stack_;
+ }
+ 
+ std::unordered_map<const ir::AstNode *, Type *> &Checker::NodeCache()
+ {
+-    return nodeCache_;
++    return node_cache_;
+ }
+ 
+ CheckerStatus Checker::Status()
+@@ -244,13 +244,13 @@ CheckerStatus Checker::Status()
+ 
+ Type *Checker::CheckTypeCached(const ir::Expression *expr)
+ {
+-    auto res = nodeCache_.find(expr);
+-    if (res != nodeCache_.end()) {
++    auto res = node_cache_.find(expr);
++    if (res != node_cache_.end()) {
+         return res->second;
+     }
+ 
+     Type *returnType = expr->Check(this);
+-    nodeCache_.insert({expr, returnType});
++    node_cache_.insert({expr, returnType});
+ 
+     return returnType;
+ }
+diff --git a/typescript/checker.h b/typescript/checker.h
+index 7063aa6..51da1bc 100644
+--- a/typescript/checker.h
++++ b/typescript/checker.h
+@@ -125,12 +125,12 @@ public:
+     NO_COPY_SEMANTIC(ObjectLiteralElaborationData);
+     NO_MOVE_SEMANTIC(ObjectLiteralElaborationData);
+ 
+-    ObjectDescriptor *desc {};
+-    std::vector<Type *> stringIndexTypes {};
+-    Type *numberInfosType {};
+-    Type *stringInfosType {};
+-    std::vector<const ir::SpreadElement *> spreads {};
+-    std::unordered_map<uint32_t, ObjectType *> potentialObjectTypes {};
++    ObjectDescriptor *desc_ {};
++    std::vector<Type *> string_index_types_ {};
++    Type *number_infos_type_ {};
++    Type *string_infos_type_ {};
++    std::vector<const ir::SpreadElement *> spreads_ {};
++    std::unordered_map<uint32_t, ObjectType *> potential_object_types_ {};
+ };
+ 
+ class ObjectLiteralPropertyInfo {
+@@ -140,9 +140,9 @@ public:
+     NO_COPY_SEMANTIC(ObjectLiteralPropertyInfo);
+     DEFAULT_MOVE_SEMANTIC(ObjectLiteralPropertyInfo);
+ 
+-    util::StringView propName {};
+-    Type *propType {};
+-    bool handleNextProp {};
++    util::StringView prop_name_ {};
++    Type *prop_type_ {};
++    bool handle_next_prop_ {};
+ };
+ 
+ class FunctionParameterInfo {
+@@ -152,14 +152,14 @@ public:
+     NO_COPY_SEMANTIC(FunctionParameterInfo);
+     DEFAULT_MOVE_SEMANTIC(FunctionParameterInfo);
+ 
+-    const ir::Expression *typeAnnotation {};
+-    const ir::Expression *initNode {};
+-    const ir::Expression *bindingNode {};
+-    Type *initType {};
+-    Type *restType {};
+-    DestructuringType destructuringType {DestructuringType::NO_DESTRUCTURING};
+-    bool optionalParam {};
+-    util::StringView paramName {};
++    const ir::Expression *type_annotation_ {};
++    const ir::Expression *init_node_ {};
++    const ir::Expression *binding_node_ {};
++    Type *init_type_ {};
++    Type *rest_type_ {};
++    DestructuringType destructuring_type_ {DestructuringType::NO_DESTRUCTURING};
++    bool optional_param_ {};
++    util::StringView param_name_ {};
+ };
+ 
+ enum class CheckerStatus {
+@@ -473,37 +473,37 @@ public:
+ private:
+     ArenaAllocator *allocator_;
+     binder::Binder *binder_;
+-    const ir::BlockStatement *rootNode_;
++    const ir::BlockStatement *root_node_;
+     binder::Scope *scope_;
+-    GlobalTypesHolder *globalTypes_;
++    GlobalTypesHolder *global_types_;
+ 
+-    NumberLiteralPool numberLiteralMap_;
+-    StringLiteralPool stringLiteralMap_;
+-    StringLiteralPool bigintLiteralMap_;
++    NumberLiteralPool number_literal_map_;
++    StringLiteralPool string_literal_map_;
++    StringLiteralPool bigint_literal_map_;
+ 
+     TypeRelation *relation_;
+ 
+-    RelationHolder identicalResults_;
+-    RelationHolder assignableResults_;
+-    RelationHolder comparableResults_;
++    RelationHolder identical_results_;
++    RelationHolder assignable_results_;
++    RelationHolder comparable_results_;
+ 
+-    std::unordered_set<const ir::AstNode *> typeStack_;
+-    std::unordered_map<const ir::AstNode *, Type *> nodeCache_;
+-    std::vector<binder::Scope *> scopeStack_;
++    std::unordered_set<const ir::AstNode *> type_stack_;
++    std::unordered_map<const ir::AstNode *, Type *> node_cache_;
++    std::vector<binder::Scope *> scope_stack_;
+ 
+     CheckerStatus status_;
+ };
+ 
+ class ScopeContext {
+ public:
+-    explicit ScopeContext(Checker *checker, binder::Scope *newScope) : checker_(checker), prevScope_(checker_->scope_)
++    explicit ScopeContext(Checker *checker, binder::Scope *newScope) : checker_(checker), prev_scope_(checker_->scope_)
+     {
+         checker_->scope_ = newScope;
+     }
+ 
+     ~ScopeContext()
+     {
+-        checker_->scope_ = prevScope_;
++        checker_->scope_ = prev_scope_;
+     }
+ 
+     NO_COPY_SEMANTIC(ScopeContext);
+@@ -511,7 +511,7 @@ public:
+ 
+ private:
+     Checker *checker_;
+-    binder::Scope *prevScope_;
++    binder::Scope *prev_scope_;
+ };
+ 
+ }  // namespace panda::es2panda::checker
+diff --git a/typescript/core/destructuring.cpp b/typescript/core/destructuring.cpp
+index 0e875a4..1cbe84c 100644
+--- a/typescript/core/destructuring.cpp
++++ b/typescript/core/destructuring.cpp
+@@ -95,27 +95,27 @@ void Checker::HandleIdentifierDeclarationWithContext(const ir::Identifier *ident
+     binder::ScopeFindResult result = scope_->Find(identName);
+ 
+     if (inAssignment) {
+-        if (!result.variable) {
++        if (!result.variable_) {
+             ThrowTypeError({"Cannot find name '", identName, "'."}, identNode->Start());
+         }
+ 
+         Type *varType = GetVariableType(identName, inferedType, nullptr, nullptr, destructuringType, identNode->Start(),
+                                         annotationTypeUsed, true);
+ 
+-        if (!IsTypeAssignableTo(varType, result.variable->TsType())) {
+-            ThrowAssignmentError(varType, result.variable->TsType(), identNode->Start());
++        if (!IsTypeAssignableTo(varType, result.variable_->TsType())) {
++            ThrowAssignmentError(varType, result.variable_->TsType(), identNode->Start());
+         }
+ 
+         return;
+     }
+ 
+-    ASSERT(result.variable);
++    ASSERT(result.variable_);
+ 
+-    Type *varType = GetVariableType(identNode->Name(), inferedType, nullptr, result.variable, destructuringType,
++    Type *varType = GetVariableType(identNode->Name(), inferedType, nullptr, result.variable_, destructuringType,
+                                     identNode->Start(), annotationTypeUsed);
+ 
+-    varType->SetVariable(result.variable);
+-    result.variable->SetTsType(varType);
++    varType->SetVariable(result.variable_);
++    result.variable_->SetTsType(varType);
+ }
+ 
+ void Checker::HandlePropertyDeclarationWithContext(const ir::Property *prop, Type *inferedType,
+@@ -170,7 +170,7 @@ void Checker::HandlePropertyDeclarationWithContext(const ir::Property *prop, Typ
+ 
+     if (fetchVar) {
+         binder::ScopeFindResult result = scope_->Find(searchVarName);
+-        resultVar = result.variable;
++        resultVar = result.variable_;
+     }
+     if (fetchVar && inAssignment && !resultVar) {
+         ThrowTypeError({"No value exists in scope for the shorthand property '", searchVarName,
+@@ -208,31 +208,31 @@ void Checker::HandleAssignmentPatternWithContext(const ir::AssignmentExpression
+         binder::ScopeFindResult result = scope_->Find(identNode->Name());
+ 
+         if (inAssignment) {
+-            if (!result.variable) {
++            if (!result.variable_) {
+                 ThrowTypeError({"Cannot find name '", identNode->Name(), "'."}, identNode->Start());
+             }
+ 
+-            if (!IsTypeAssignableTo(initType, result.variable->TsType())) {
+-                ThrowAssignmentError(initType, result.variable->TsType(), identNode->Start());
++            if (!IsTypeAssignableTo(initType, result.variable_->TsType())) {
++                ThrowAssignmentError(initType, result.variable_->TsType(), identNode->Start());
+             }
+ 
+             Type *varType = GetVariableType(identNode->Name(), inferedType, GetBaseTypeOfLiteralType(initType), nullptr,
+                                             destructuringType, identNode->Start(), annotationTypeUsed, true);
+ 
+-            if (!IsTypeAssignableTo(varType, result.variable->TsType())) {
+-                ThrowAssignmentError(varType, result.variable->TsType(), identNode->Start());
++            if (!IsTypeAssignableTo(varType, result.variable_->TsType())) {
++                ThrowAssignmentError(varType, result.variable_->TsType(), identNode->Start());
+             }
+ 
+             return;
+         }
+ 
+-        ASSERT(result.variable);
++        ASSERT(result.variable_);
+ 
+         Type *varType = GetVariableType(identNode->Name(), inferedType, GetBaseTypeOfLiteralType(initType),
+-                                        result.variable, destructuringType, identNode->Start(), annotationTypeUsed);
++                                        result.variable_, destructuringType, identNode->Start(), annotationTypeUsed);
+ 
+-        varType->SetVariable(result.variable);
+-        result.variable->SetTsType(varType);
++        varType->SetVariable(result.variable_);
++        result.variable_->SetTsType(varType);
+ 
+         return;
+     }
+@@ -313,13 +313,13 @@ void Checker::HandleRestElementWithContext(const ir::SpreadElement *restElement,
+ 
+     if (restElement->Argument()->IsIdentifier()) {
+         binder::ScopeFindResult result = scope_->Find(restElement->Argument()->AsIdentifier()->Name());
+-        if (inAssignment && !result.variable) {
++        if (inAssignment && !result.variable_) {
+             ThrowTypeError({"Cannot find name '", restElement->Argument()->AsIdentifier()->Name(), "'."},
+                            restElement->Argument()->Start());
+         }
+ 
+-        ASSERT(result.variable);
+-        restVar = result.variable;
++        ASSERT(result.variable_);
++        restVar = result.variable_;
+     }
+ 
+     Type *restType =
+@@ -675,7 +675,7 @@ Type *Checker::CreateObjectTypeForRest(ObjectType *objType)
+             memberVar->SetTsType(it->TsType());
+             it->RemoveFlag(binder::VariableFlags::INFERED_IN_PATTERN);
+             memberVar->AddFlag(it->Flags());
+-            desc->properties.push_back(memberVar);
++            desc->properties_.push_back(memberVar);
+         }
+     }
+ 
+@@ -699,7 +699,7 @@ Type *Checker::CreateTupleTypeForRest(TupleTypeIterator *iterator)
+         auto *memberVar = binder::Scope::CreateVar(allocator_, memberIndex, binder::VariableFlags::PROPERTY, nullptr);
+         memberVar->SetTsType(elementType);
+         elementFlags.insert({memberIndex, memberFlag});
+-        desc->properties.push_back(memberVar);
++        desc->properties_.push_back(memberVar);
+ 
+         index++;
+         iter = iterator->Next();
+@@ -795,7 +795,7 @@ Type *Checker::CreateInitializerTypeForArrayPattern(const TupleType *patternType
+ 
+     ObjectType *initTupleType = initNode->Check(this)->AsObjectType()->AsTupleType();
+ 
+-    nodeCache_.insert({initNode, initTupleType});
++    node_cache_.insert({initNode, initTupleType});
+ 
+     for (size_t it = 0; it < initNode->Elements().size(); it++) {
+         if (patternType->FixedLength() < it) {
+diff --git a/typescript/core/function.cpp b/typescript/core/function.cpp
+index 09006bd..cc9d0fd 100644
+--- a/typescript/core/function.cpp
++++ b/typescript/core/function.cpp
+@@ -150,68 +150,68 @@ Type *Checker::CreateTypeForPatternParameter(const ir::Expression *patternNode,
+ void Checker::CheckFunctionParameterDeclaration(const ArenaVector<ir::Expression *> &params,
+                                                 SignatureInfo *signatureInfo)
+ {
+-    signatureInfo->restVar = nullptr;
+-    signatureInfo->minArgCount = 0;
++    signatureInfo->rest_var_ = nullptr;
++    signatureInfo->min_arg_count_ = 0;
+ 
+     for (auto *it : params) {
+         FunctionParameterInfo paramInfo = GetFunctionParameterInfo(it);
+ 
+         VariableBindingContext context = VariableBindingContext::REGULAR;
+ 
+-        Type *annotationType = paramInfo.typeAnnotation ? CheckTypeCached(paramInfo.typeAnnotation) : nullptr;
++        Type *annotationType = paramInfo.type_annotation_ ? CheckTypeCached(paramInfo.type_annotation_) : nullptr;
+ 
+         TypeOrNode elaborateSource;
+ 
+-        if (paramInfo.initNode && annotationType) {
+-            elaborateSource = paramInfo.initNode;
++        if (paramInfo.init_node_ && annotationType) {
++            elaborateSource = paramInfo.init_node_;
+             if (!ElaborateElementwise(elaborateSource, annotationType, it->Start()) &&
+-                !IsTypeAssignableTo(paramInfo.initType, annotationType)) {
++                !IsTypeAssignableTo(paramInfo.init_type_, annotationType)) {
+                 ThrowTypeError(
+-                    {"Type '", AsSrc(paramInfo.initType), "' is not assignable to type '", annotationType, "'"},
++                    {"Type '", AsSrc(paramInfo.init_type_), "' is not assignable to type '", annotationType, "'"},
+                     it->Start());
+             }
+         }
+ 
+-        Type *patternType = paramInfo.destructuringType != DestructuringType::NO_DESTRUCTURING
+-                                ? paramInfo.bindingNode->Check(this)
++        Type *patternType = paramInfo.destructuring_type_ != DestructuringType::NO_DESTRUCTURING
++                                ? paramInfo.binding_node_->Check(this)
+                                 : nullptr;
+ 
+         if (patternType) {
+             if (annotationType) {
+                 elaborateSource = patternType;
+                 ElaborateElementwise(elaborateSource, annotationType, it->Start());
+-            } else if (paramInfo.initNode) {
+-                paramInfo.initType = CreateInitializerTypeForPattern(patternType, paramInfo.initNode);
++            } else if (paramInfo.init_node_) {
++                paramInfo.init_type_ = CreateInitializerTypeForPattern(patternType, paramInfo.init_node_);
+             }
+         }
+ 
+         Type *paramType = GetParamTypeFromParamInfo(paramInfo, annotationType, patternType);
+ 
+-        HandleVariableDeclarationWithContext(paramInfo.bindingNode, paramType, context, paramInfo.destructuringType,
+-                                             paramInfo.typeAnnotation);
++        HandleVariableDeclarationWithContext(paramInfo.binding_node_, paramType, context, paramInfo.destructuring_type_,
++                                             paramInfo.type_annotation_);
+ 
+         // TODO(aszilagyi): get the variable from the function scope
+         binder::LocalVariable *paramVar = nullptr;
+ 
+-        paramType = paramInfo.destructuringType != DestructuringType::NO_DESTRUCTURING
+-                        ? CreateTypeForPatternParameter(paramInfo.bindingNode, paramInfo.initNode)
++        paramType = paramInfo.destructuring_type_ != DestructuringType::NO_DESTRUCTURING
++                        ? CreateTypeForPatternParameter(paramInfo.binding_node_, paramInfo.init_node_)
+                         : paramType;
+ 
+         paramType->SetVariable(paramVar);
+         paramVar->SetTsType(paramType);
+ 
+-        if (paramInfo.restType) {
+-            signatureInfo->restVar = paramVar;
++        if (paramInfo.rest_type_) {
++            signatureInfo->rest_var_ = paramVar;
+             continue;
+         }
+ 
+-        if (!paramInfo.optionalParam) {
+-            signatureInfo->minArgCount++;
++        if (!paramInfo.optional_param_) {
++            signatureInfo->min_arg_count_++;
+         } else {
+             paramVar->AddFlag(binder::VariableFlags::OPTIONAL);
+         }
+ 
+-        signatureInfo->funcParams.push_back(paramVar);
++        signatureInfo->func_params_.push_back(paramVar);
+     }
+ }
+ 
+@@ -235,12 +235,12 @@ void Checker::InferFunctionDeclarationType(const binder::FunctionDecl *decl, bin
+ 
+             Signature *overloadSignature = allocator_->New<Signature>(signatureInfo, returnType);
+ 
+-            descWithOverload->callSignatures.push_back(overloadSignature);
++            descWithOverload->call_signatures_.push_back(overloadSignature);
+ 
+             continue;
+         }
+ 
+-        if (descWithOverload->callSignatures.empty()) {
++        if (descWithOverload->call_signatures_.empty()) {
+             ScopeContext scopeCtx(this, func->Scope());
+ 
+             auto *signatureInfo = allocator_->New<checker::SignatureInfo>();
+@@ -335,54 +335,54 @@ FunctionParameterInfo Checker::GetFunctionParameterInfo(ir::Expression *expr)
+ {
+     std::stringstream ss;
+     FunctionParameterInfo paramInfo;
+-    paramInfo.bindingNode = expr;
++    paramInfo.binding_node_ = expr;
+ 
+     if (expr->IsArrayPattern()) {
+-        paramInfo.typeAnnotation = expr->AsArrayPattern()->TypeAnnotation();
+-        paramInfo.destructuringType = DestructuringType::ARRAY_DESTRUCTURING;
++        paramInfo.type_annotation_ = expr->AsArrayPattern()->TypeAnnotation();
++        paramInfo.destructuring_type_ = DestructuringType::ARRAY_DESTRUCTURING;
+         CreatePatternName(expr, ss);
+         util::UString pn(ss.str(), allocator_);
+-        paramInfo.paramName = pn.View();
++        paramInfo.param_name_ = pn.View();
+         return paramInfo;
+     }
+ 
+     if (expr->IsObjectPattern()) {
+-        paramInfo.typeAnnotation = expr->AsObjectPattern()->TypeAnnotation();
+-        paramInfo.destructuringType = DestructuringType::OBJECT_DESTRUCTURING;
++        paramInfo.type_annotation_ = expr->AsObjectPattern()->TypeAnnotation();
++        paramInfo.destructuring_type_ = DestructuringType::OBJECT_DESTRUCTURING;
+         CreatePatternName(expr, ss);
+         util::UString pn(ss.str(), allocator_);
+-        paramInfo.paramName = pn.View();
++        paramInfo.param_name_ = pn.View();
+         return paramInfo;
+     }
+ 
+     if (expr->IsAssignmentPattern()) {
+         ir::AssignmentExpression *assignmentPattern = expr->AsAssignmentPattern();
+-        paramInfo.initNode = assignmentPattern->Right();
+-        paramInfo.bindingNode = assignmentPattern->Left();
+-        paramInfo.optionalParam = true;
++        paramInfo.init_node_ = assignmentPattern->Right();
++        paramInfo.binding_node_ = assignmentPattern->Left();
++        paramInfo.optional_param_ = true;
+ 
+-        if (paramInfo.bindingNode->IsArrayPattern()) {
+-            paramInfo.typeAnnotation = paramInfo.bindingNode->AsArrayPattern()->TypeAnnotation();
++        if (paramInfo.binding_node_->IsArrayPattern()) {
++            paramInfo.type_annotation_ = paramInfo.binding_node_->AsArrayPattern()->TypeAnnotation();
+             // TODO(aszilagyi): 1st param true
+-            paramInfo.initType = expr->AsAssignmentPattern()->Right()->Check(this);
+-            paramInfo.destructuringType = DestructuringType::ARRAY_DESTRUCTURING;
++            paramInfo.init_type_ = expr->AsAssignmentPattern()->Right()->Check(this);
++            paramInfo.destructuring_type_ = DestructuringType::ARRAY_DESTRUCTURING;
+             CreatePatternName(expr, ss);
+             util::UString pn(ss.str(), allocator_);
+-            paramInfo.paramName = pn.View();
++            paramInfo.param_name_ = pn.View();
+         } else {
+-            if (paramInfo.bindingNode->IsObjectPattern()) {
+-                paramInfo.typeAnnotation = paramInfo.bindingNode->AsObjectPattern()->TypeAnnotation();
+-                paramInfo.destructuringType = DestructuringType::OBJECT_DESTRUCTURING;
++            if (paramInfo.binding_node_->IsObjectPattern()) {
++                paramInfo.type_annotation_ = paramInfo.binding_node_->AsObjectPattern()->TypeAnnotation();
++                paramInfo.destructuring_type_ = DestructuringType::OBJECT_DESTRUCTURING;
+                 CreatePatternName(expr, ss);
+                 util::UString pn(ss.str(), allocator_);
+-                paramInfo.paramName = pn.View();
++                paramInfo.param_name_ = pn.View();
+             } else {
+-                ASSERT(paramInfo.bindingNode->IsIdentifier());
+-                paramInfo.typeAnnotation = paramInfo.bindingNode->AsIdentifier()->TypeAnnotation();
+-                paramInfo.paramName = paramInfo.bindingNode->AsIdentifier()->Name();
++                ASSERT(paramInfo.binding_node_->IsIdentifier());
++                paramInfo.type_annotation_ = paramInfo.binding_node_->AsIdentifier()->TypeAnnotation();
++                paramInfo.param_name_ = paramInfo.binding_node_->AsIdentifier()->Name();
+             }
+ 
+-            paramInfo.initType = expr->AsAssignmentPattern()->Right()->Check(this);
++            paramInfo.init_type_ = expr->AsAssignmentPattern()->Right()->Check(this);
+         }
+ 
+         return paramInfo;
+@@ -390,7 +390,7 @@ FunctionParameterInfo Checker::GetFunctionParameterInfo(ir::Expression *expr)
+ 
+     if (expr->IsRestElement()) {
+         ir::SpreadElement *restElement = expr->AsRestElement();
+-        paramInfo.restType = GlobalAnyType();
++        paramInfo.rest_type_ = GlobalAnyType();
+ 
+         if (restElement->TypeAnnotation()) {
+             Type *restArrayType = restElement->TypeAnnotation()->Check(this);
+@@ -399,19 +399,19 @@ FunctionParameterInfo Checker::GetFunctionParameterInfo(ir::Expression *expr)
+                 ThrowTypeError("A rest parameter must be of an array type", expr->Start());
+             }
+ 
+-            paramInfo.restType = restArrayType->AsArrayType()->ElementType();
++            paramInfo.rest_type_ = restArrayType->AsArrayType()->ElementType();
+         }
+ 
+-        paramInfo.paramName = restElement->Argument()->AsIdentifier()->Name();
+-        paramInfo.bindingNode = restElement->Argument();
++        paramInfo.param_name_ = restElement->Argument()->AsIdentifier()->Name();
++        paramInfo.binding_node_ = restElement->Argument();
+ 
+         return paramInfo;
+     }
+ 
+     ASSERT(expr->IsIdentifier());
+-    paramInfo.typeAnnotation = expr->AsIdentifier()->TypeAnnotation();
+-    paramInfo.optionalParam = expr->AsIdentifier()->IsOptional();
+-    paramInfo.paramName = expr->AsIdentifier()->Name();
++    paramInfo.type_annotation_ = expr->AsIdentifier()->TypeAnnotation();
++    paramInfo.optional_param_ = expr->AsIdentifier()->IsOptional();
++    paramInfo.param_name_ = expr->AsIdentifier()->Name();
+ 
+     return paramInfo;
+ }
+@@ -419,20 +419,20 @@ FunctionParameterInfo Checker::GetFunctionParameterInfo(ir::Expression *expr)
+ Type *Checker::GetParamTypeFromParamInfo(const FunctionParameterInfo &paramInfo, Type *annotationType,
+                                          Type *patternType)
+ {
+-    if (paramInfo.typeAnnotation) {
++    if (paramInfo.type_annotation_) {
+         return annotationType;
+     }
+ 
+-    if (paramInfo.initType) {
+-        return paramInfo.initType;
++    if (paramInfo.init_type_) {
++        return paramInfo.init_type_;
+     }
+ 
+     if (patternType) {
+         return patternType;
+     }
+ 
+-    if (paramInfo.restType) {
+-        return paramInfo.restType;
++    if (paramInfo.rest_type_) {
++        return paramInfo.rest_type_;
+     }
+ 
+     return GlobalAnyType();
+diff --git a/typescript/core/generics.cpp b/typescript/core/generics.cpp
+index b3ee8bb..446566c 100644
+--- a/typescript/core/generics.cpp
++++ b/typescript/core/generics.cpp
+@@ -60,9 +60,9 @@ Type *Checker::InstantiateGenericTypeAlias(binder::Variable *bindingVar, const i
+         for (size_t it = 0; it < typeParams->Params().size(); it++) {
+             binder::ScopeFindResult res = scope_->Find(decl->Params()[it]->Name()->Name());
+ 
+-            ASSERT(res.variable && res.variable->TsType() && res.variable->TsType()->IsTypeParameter());
++            ASSERT(res.variable_ && res.variable_->TsType() && res.variable_->TsType()->IsTypeParameter());
+ 
+-            TypeParameter *currentTypeParameterType = res.variable->TsType()->AsTypeParameter();
++            TypeParameter *currentTypeParameterType = res.variable_->TsType()->AsTypeParameter();
+ 
+             savedDefaultTypes.emplace_back(currentTypeParameterType, currentTypeParameterType->DefaultType());
+ 
+@@ -70,7 +70,7 @@ Type *Checker::InstantiateGenericTypeAlias(binder::Variable *bindingVar, const i
+         }
+     }
+ 
+-    Type *newGenericType = bindingVar->TsType()->Instantiate(allocator_, relation_, globalTypes_);
++    Type *newGenericType = bindingVar->TsType()->Instantiate(allocator_, relation_, global_types_);
+ 
+     for (auto it : savedDefaultTypes) {
+         it.first->SetDefaultType(it.second);
+@@ -123,9 +123,9 @@ Type *Checker::InstantiateGenericInterface(binder::Variable *bindingVar, const b
+         for (size_t i = 0; i < currentTypeParams->Params().size(); i++) {
+             binder::ScopeFindResult res = scope_->Find(currentTypeParams->Params()[i]->Name()->Name());
+ 
+-            ASSERT(res.variable && res.variable->TsType() && res.variable->TsType()->IsTypeParameter());
++            ASSERT(res.variable_ && res.variable_->TsType() && res.variable_->TsType()->IsTypeParameter());
+ 
+-            TypeParameter *currentTypeParameterType = res.variable->TsType()->AsTypeParameter();
++            TypeParameter *currentTypeParameterType = res.variable_->TsType()->AsTypeParameter();
+ 
+             savedDefaultTypes.emplace_back(currentTypeParameterType, currentTypeParameterType->DefaultType());
+ 
+@@ -134,7 +134,7 @@ Type *Checker::InstantiateGenericInterface(binder::Variable *bindingVar, const b
+         }
+     }
+ 
+-    Type *newGenericType = bindingVar->TsType()->Instantiate(allocator_, relation_, globalTypes_);
++    Type *newGenericType = bindingVar->TsType()->Instantiate(allocator_, relation_, global_types_);
+ 
+     newGenericType->AsObjectType()->AsInterfaceType()->SetTypeParamTypes(std::move(typeParamInstantiationTypes));
+ 
+@@ -176,30 +176,30 @@ std::vector<binder::Variable *> Checker::CheckTypeParameters(const ir::TSTypePar
+         const ir::TSTypeParameter *currentParam = typeParams->Params()[i];
+ 
+         binder::ScopeFindResult res = scope_->Find(currentParam->Name()->Name());
+-        ASSERT(res.variable);
++        ASSERT(res.variable_);
+ 
+-        if (!res.variable->TsType()) {
++        if (!res.variable_->TsType()) {
+             Type *defaultType = nullptr;
+             if (currentParam->DefaultType()) {
+                 CheckTypeParametersNotReferenced(currentParam->DefaultType(), typeParams, i + 1);
+ 
+-                if (!typeStack_.insert(currentParam->DefaultType()).second) {
++                if (!type_stack_.insert(currentParam->DefaultType()).second) {
+                     ThrowTypeError({"Type parameter '", currentParam->Name()->Name(), "' has a circular default."},
+                                    currentParam->DefaultType()->Start());
+                 }
+ 
+                 defaultType = currentParam->DefaultType()->Check(this);
+ 
+-                typeStack_.erase(currentParam->DefaultType());
++                type_stack_.erase(currentParam->DefaultType());
+             }
+ 
+             // TODO(aszilagyi): handle type parameter constraints
+             auto *paramType = allocator_->New<TypeParameter>(nullptr, defaultType);
+ 
+-            res.variable->SetTsType(paramType);
++            res.variable_->SetTsType(paramType);
+         }
+ 
+-        params.push_back(res.variable);
++        params.push_back(res.variable_);
+     }
+ 
+     return params;
+diff --git a/typescript/core/helpers.cpp b/typescript/core/helpers.cpp
+index 18d6640..bfad37a 100644
+--- a/typescript/core/helpers.cpp
++++ b/typescript/core/helpers.cpp
+@@ -55,9 +55,9 @@ void Checker::CheckReferenceExpression(const ir::Expression *expr, const char *i
+     if (expr->IsIdentifier()) {
+         const util::StringView &name = expr->AsIdentifier()->Name();
+         binder::ScopeFindResult result = scope_->Find(name);
+-        ASSERT(result.variable);
++        ASSERT(result.variable_);
+ 
+-        if (result.variable->HasFlag(binder::VariableFlags::ENUM_LITERAL)) {
++        if (result.variable_->HasFlag(binder::VariableFlags::ENUM_LITERAL)) {
+             ThrowTypeError({"Cannot assign to '", name, "' because it is not a variable."}, expr->Start());
+         }
+     } else if (!expr->IsMemberExpression()) {
+@@ -88,18 +88,18 @@ void Checker::CheckTestingKnownTruthyCallableOrAwaitableType(const ir::Expressio
+ 
+     if (location->IsIdentifier()) {
+         result = scope_->Find(location->AsIdentifier()->Name(), binder::ResolveBindingOptions::ALL);
+-        ASSERT(result.variable);
+-        testVar = result.variable;
++        ASSERT(result.variable_);
++        testVar = result.variable_;
+     } else if (location->IsBinaryExpression() && location->AsBinaryExpression()->Right()->IsIdentifier()) {
+         result = scope_->Find(location->AsBinaryExpression()->Right()->AsIdentifier()->Name(),
+                               binder::ResolveBindingOptions::ALL);
+-        ASSERT(result.variable);
+-        testVar = result.variable;
++        ASSERT(result.variable_);
++        testVar = result.variable_;
+     } else if (location->IsAssignmentExpression() && location->AsAssignmentExpression()->Right()->IsIdentifier()) {
+         result = scope_->Find(location->AsAssignmentExpression()->Right()->AsIdentifier()->Name(),
+                               binder::ResolveBindingOptions::ALL);
+-        ASSERT(result.variable);
+-        testVar = result.variable;
++        ASSERT(result.variable_);
++        testVar = result.variable_;
+     } else if (location->IsMemberExpression() && !location->AsMemberExpression()->IsComputed()) {
+         testVar = ResolveNonComputedObjectProperty(location->AsMemberExpression());
+     }
+@@ -231,8 +231,8 @@ bool Checker::IsVariableUsedInConditionBody(const ir::AstNode *parent, binder::V
+             resultVar = ResolveNonComputedObjectProperty(childNode->AsMemberExpression());
+         } else if (childNode->IsIdentifier()) {
+             binder::ScopeFindResult result = scope_->Find(childNode->AsIdentifier()->Name());
+-            ASSERT(result.variable);
+-            resultVar = result.variable;
++            ASSERT(result.variable_);
++            resultVar = result.variable_;
+         }
+ 
+         if (searchVar == resultVar) {
+@@ -255,8 +255,8 @@ bool Checker::FindVariableInBinaryExpressionChain(const ir::AstNode *parent, bin
+     parent->Iterate([this, searchVar, &found](const ir::AstNode *childNode) -> void {
+         if (childNode->IsIdentifier()) {
+             binder::ScopeFindResult result = scope_->Find(childNode->AsIdentifier()->Name());
+-            ASSERT(result.variable);
+-            if (result.variable == searchVar) {
++            ASSERT(result.variable_);
++            if (result.variable_ == searchVar) {
+                 found = true;
+                 return;
+             }
+diff --git a/typescript/core/object.cpp b/typescript/core/object.cpp
+index 917e5b2..a29cc81 100644
+--- a/typescript/core/object.cpp
++++ b/typescript/core/object.cpp
+@@ -44,43 +44,43 @@ ObjectLiteralPropertyInfo Checker::HandleObjectLiteralProperty(const ir::Propert
+ 
+     const ir::Expression *propValue = prop->Value();
+     // TODO(aszilagyi): params readonly, readonly
+-    propInfo.propType = shorthand ? GlobalAnyType() : propValue->Check(this);
++    propInfo.prop_type_ = shorthand ? GlobalAnyType() : propValue->Check(this);
+ 
+     if (prop->Kind() == ir::PropertyKind::GET) {
+         const ir::ScriptFunction *func = prop->Value()->AsFunctionExpression()->Function();
+         CheckAllCodePathsInNonVoidFunctionReturnOrThrow(func, prop->Start(), "A 'get' accessor must return a value.");
+ 
+-        ASSERT(propInfo.propType->AsObjectType()->IsFunctionType());
+-        propInfo.propType = propInfo.propType->AsObjectType()->CallSignatures()[0]->ReturnType();
++        ASSERT(propInfo.prop_type_->AsObjectType()->IsFunctionType());
++        propInfo.prop_type_ = propInfo.prop_type_->AsObjectType()->CallSignatures()[0]->ReturnType();
+     } else if (prop->Kind() == ir::PropertyKind::SET) {
+-        ASSERT(propInfo.propType->AsObjectType()->IsFunctionType());
+-        propInfo.propType = propInfo.propType->AsObjectType()->CallSignatures()[0]->Params()[0]->TsType();
++        ASSERT(propInfo.prop_type_->AsObjectType()->IsFunctionType());
++        propInfo.prop_type_ = propInfo.prop_type_->AsObjectType()->CallSignatures()[0]->Params()[0]->TsType();
+     }
+ 
+     if (!readonly) {
+-        propInfo.propType = GetBaseTypeOfLiteralType(propInfo.propType);
++        propInfo.prop_type_ = GetBaseTypeOfLiteralType(propInfo.prop_type_);
+     }
+ 
+     if (computed) {
+-        propInfo.propName = HandleComputedPropertyName(prop->Key(), desc, propInfo.propType, stringIndexTypes,
+-                                                       &propInfo.handleNextProp, prop->Start(), readonly);
++        propInfo.prop_name_ = HandleComputedPropertyName(prop->Key(), desc, propInfo.prop_type_, stringIndexTypes,
++                                                         &propInfo.handle_next_prop_, prop->Start(), readonly);
+ 
+-        if (propInfo.handleNextProp) {
++        if (propInfo.handle_next_prop_) {
+             return propInfo;
+         }
+     } else {
+-        propInfo.propName = ToPropertyName(prop->Key(), TypeFlag::COMPUTED_TYPE_LITERAL_NAME);
++        propInfo.prop_name_ = ToPropertyName(prop->Key(), TypeFlag::COMPUTED_TYPE_LITERAL_NAME);
+     }
+ 
+     if (shorthand) {
+-        binder::ScopeFindResult result = scope_->Find(propInfo.propName);
+-        if (!result.variable) {
+-            ThrowTypeError({"No value exists in scope for the shorthand property '", propInfo.propName,
++        binder::ScopeFindResult result = scope_->Find(propInfo.prop_name_);
++        if (!result.variable_) {
++            ThrowTypeError({"No value exists in scope for the shorthand property '", propInfo.prop_name_,
+                             "'. Either declare one ", "or provide an initializer."},
+                            prop->Start());
+         } else {
+             // TODO(aszilagyi): param readonly
+-            propInfo.propType = prop->Key()->Check(this);
++            propInfo.prop_type_ = prop->Key()->Check(this);
+         }
+     }
+ 
+@@ -97,7 +97,7 @@ void Checker::HandleSpreadElement(const ir::SpreadElement *spreadElem, ObjectDes
+ 
+     Type *spreadType = nullptr;
+     binder::ScopeFindResult result = scope_->Find(spreadElem->Argument()->AsIdentifier()->Name());
+-    if (!result.variable) {
++    if (!result.variable_) {
+         ThrowTypeError("Cannot find name ", locInfo);
+     }
+ 
+@@ -120,7 +120,7 @@ void Checker::HandleSpreadElement(const ir::SpreadElement *spreadElem, ObjectDes
+             if (readonly) {
+                 var->AddFlag(binder::VariableFlags::READONLY);
+             }
+-            desc->properties.push_back(var);
++            desc->properties_.push_back(var);
+         }
+     }
+ 
+@@ -133,7 +133,7 @@ void Checker::HandleSpreadElement(const ir::SpreadElement *spreadElem, ObjectDes
+                     res->SetTsType(prop->TsType());
+                 } else {
+                     auto *var = binder::Scope::CreateVar(allocator_, prop->Name(), prop->Flags(), nullptr);
+-                    desc->properties.push_back(var);
++                    desc->properties_.push_back(var);
+                 }
+             }
+         }
+@@ -148,7 +148,7 @@ Type *Checker::CollectStringIndexInfoTypes(const ObjectDescriptor *desc, const s
+ 
+     std::vector<Type *> collectedTypes;
+ 
+-    for (const auto *it : desc->properties) {
++    for (const auto *it : desc->properties_) {
+         if (it->TsType()->IsUnionType()) {
+             const auto &constituentTypes = it->TsType()->AsUnionType()->ConstituentTypes();
+             for (auto *type : constituentTypes) {
+@@ -170,15 +170,15 @@ Type *Checker::CollectStringIndexInfoTypes(const ObjectDescriptor *desc, const s
+         }
+     }
+ 
+-    if (desc->numberIndexInfo) {
+-        if (desc->numberIndexInfo->InfoType()->IsUnionType()) {
++    if (desc->number_index_info_) {
++        if (desc->number_index_info_->InfoType()->IsUnionType()) {
+             std::vector<Type *> &constituentTypes =
+-                desc->numberIndexInfo->InfoType()->AsUnionType()->ConstituentTypes();
++                desc->number_index_info_->InfoType()->AsUnionType()->ConstituentTypes();
+             for (auto *type : constituentTypes) {
+                 collectedTypes.push_back(type);
+             }
+         } else {
+-            collectedTypes.push_back(desc->numberIndexInfo->InfoType());
++            collectedTypes.push_back(desc->number_index_info_->InfoType());
+         }
+     }
+ 
+@@ -370,7 +370,7 @@ void Checker::PrefetchTypeLiteralProperties(const ir::Expression *current, check
+         prop->AddFlag(binder::VariableFlags::METHOD);
+     }
+ 
+-    desc->properties.push_back(prop);
++    desc->properties_.push_back(prop);
+ }
+ 
+ void Checker::CheckTsTypeLiteralOrInterfaceMember(const ir::Expression *current, ObjectDescriptor *desc)
+@@ -557,29 +557,29 @@ void Checker::CheckTsIndexSignature(const ir::TSIndexSignature *indexSignature,
+     Type *indexType = indexSignature->TypeAnnotation()->Check(this);
+ 
+     if (indexSignature->Kind() == ir::TSIndexSignature::TSIndexSignatureKind::NUMBER) {
+-        if (desc->numberIndexInfo) {
++        if (desc->number_index_info_) {
+             ThrowTypeError("Duplicate number index signature", indexSignature->Start());
+         }
+ 
+-        desc->numberIndexInfo = allocator_->New<IndexInfo>(indexType, paramName, indexSignature->Readonly());
++        desc->number_index_info_ = allocator_->New<IndexInfo>(indexType, paramName, indexSignature->Readonly());
+ 
+-        if (desc->stringIndexInfo) {
+-            IsTypeAssignableTo(indexType, desc->stringIndexInfo->InfoType(),
++        if (desc->string_index_info_) {
++            IsTypeAssignableTo(indexType, desc->string_index_info_->InfoType(),
+                                {"Numeric index type '", indexType, "' is not assignable to string index type '",
+-                                desc->stringIndexInfo->InfoType(), "'"},
++                                desc->string_index_info_->InfoType(), "'"},
+                                indexSignature->Start());
+         }
+     } else {
+         ASSERT(indexSignature->Kind() == ir::TSIndexSignature::TSIndexSignatureKind::STRING);
+-        if (desc->stringIndexInfo) {
++        if (desc->string_index_info_) {
+             ThrowTypeError("Duplicate string index signature", indexSignature->Start());
+         }
+ 
+-        desc->stringIndexInfo = allocator_->New<IndexInfo>(indexType, paramName, indexSignature->Readonly());
++        desc->string_index_info_ = allocator_->New<IndexInfo>(indexType, paramName, indexSignature->Readonly());
+ 
+-        if (desc->numberIndexInfo) {
+-            IsTypeAssignableTo(desc->numberIndexInfo->InfoType(), indexType,
+-                               {"Numeric index type '", desc->numberIndexInfo->InfoType(),
++        if (desc->number_index_info_) {
++            IsTypeAssignableTo(desc->number_index_info_->InfoType(), indexType,
++                               {"Numeric index type '", desc->number_index_info_->InfoType(),
+                                 "' is not assignable to string index type '", indexType, "'"},
+                                indexSignature->Start());
+         }
+@@ -601,9 +601,9 @@ void Checker::CheckTsSignatureDeclaration(const ir::TSSignatureDeclaration *sign
+     auto *signature = allocator_->New<Signature>(signatureInfo, returnType);
+ 
+     if (signatureNode->Kind() == ir::TSSignatureDeclaration::TSSignatureDeclarationKind::CALL_SIGNATURE) {
+-        desc->callSignatures.push_back(signature);
++        desc->call_signatures_.push_back(signature);
+     } else {
+-        desc->constructSignatures.push_back(signature);
++        desc->construct_signatures_.push_back(signature);
+     }
+ }
+ 
+@@ -647,16 +647,16 @@ void Checker::CheckTsPropertyOrMethodSignature(const ir::Expression *current, Ob
+ 
+ void Checker::HandleNumberIndexInfo(ObjectDescriptor *desc, Type *indexType, bool readonly)
+ {
+-    if (desc->numberIndexInfo) {
+-        if (desc->numberIndexInfo->InfoType()->IsUnionType()) {
+-            desc->numberIndexInfo->InfoType()->AsUnionType()->AddConstituentType(indexType, relation_);
++    if (desc->number_index_info_) {
++        if (desc->number_index_info_->InfoType()->IsUnionType()) {
++            desc->number_index_info_->InfoType()->AsUnionType()->AddConstituentType(indexType, relation_);
+         } else {
+-            Type *numIndexType = CreateUnionType({desc->numberIndexInfo->InfoType(), indexType});
+-            desc->numberIndexInfo->SetInfoType(numIndexType);
++            Type *numIndexType = CreateUnionType({desc->number_index_info_->InfoType(), indexType});
++            desc->number_index_info_->SetInfoType(numIndexType);
+         }
+     } else {
+         auto *numIndexInfo = allocator_->New<IndexInfo>(indexType, "x", readonly);
+-        desc->numberIndexInfo = numIndexInfo;
++        desc->number_index_info_ = numIndexInfo;
+     }
+ }
+ 
+@@ -669,7 +669,7 @@ util::StringView Checker::HandleComputedPropertyName(const ir::Expression *propK
+     if (propKey->IsIdentifier()) {
+         const ir::Identifier *identKey = propKey->AsIdentifier();
+         binder::ScopeFindResult result = scope_->Find(identKey->Name());
+-        if (!result.variable) {
++        if (!result.variable_) {
+             ThrowTypeError({"Cannot find name '", identKey->Name(), "'"}, locInfo);
+         }
+ 
+diff --git a/typescript/core/typeCreation.cpp b/typescript/core/typeCreation.cpp
+index 1b3aab4..e309aa9 100644
+--- a/typescript/core/typeCreation.cpp
++++ b/typescript/core/typeCreation.cpp
+@@ -20,37 +20,37 @@ namespace panda::es2panda::checker {
+ 
+ Type *Checker::CreateNumberLiteralType(double value)
+ {
+-    auto search = numberLiteralMap_.find(value);
+-    if (search != numberLiteralMap_.end()) {
++    auto search = number_literal_map_.find(value);
++    if (search != number_literal_map_.end()) {
+         return search->second;
+     }
+ 
+     auto *newNumLiteralType = allocator_->New<NumberLiteralType>(value);
+-    numberLiteralMap_.insert({value, newNumLiteralType});
++    number_literal_map_.insert({value, newNumLiteralType});
+     return newNumLiteralType;
+ }
+ 
+ Type *Checker::CreateBigintLiteralType(const util::StringView &str, bool negative)
+ {
+-    auto search = bigintLiteralMap_.find(str);
+-    if (search != bigintLiteralMap_.end()) {
++    auto search = bigint_literal_map_.find(str);
++    if (search != bigint_literal_map_.end()) {
+         return search->second;
+     }
+ 
+     auto *newBigiLiteralType = allocator_->New<BigintLiteralType>(str, negative);
+-    bigintLiteralMap_.insert({str, newBigiLiteralType});
++    bigint_literal_map_.insert({str, newBigiLiteralType});
+     return newBigiLiteralType;
+ }
+ 
+ Type *Checker::CreateStringLiteralType(const util::StringView &str)
+ {
+-    auto search = stringLiteralMap_.find(str);
+-    if (search != stringLiteralMap_.end()) {
++    auto search = string_literal_map_.find(str);
++    if (search != string_literal_map_.end()) {
+         return search->second;
+     }
+ 
+     auto *newStrLiteralType = allocator_->New<StringLiteralType>(str);
+-    stringLiteralMap_.insert({str, newStrLiteralType});
++    string_literal_map_.insert({str, newStrLiteralType});
+     return newStrLiteralType;
+ }
+ 
+@@ -74,7 +74,7 @@ Type *Checker::CreateUnionType(std::vector<Type *> &&constituentTypes)
+ 
+     auto *newUnionType = allocator_->New<UnionType>(std::move(constituentTypes));
+ 
+-    return UnionType::HandleUnionType(newUnionType, globalTypes_);
++    return UnionType::HandleUnionType(newUnionType, global_types_);
+ }
+ 
+ Type *Checker::CreateFunctionTypeWithSignature(Signature *callSignature)
+@@ -94,7 +94,7 @@ Type *Checker::CreateConstructorTypeWithSignature(Signature *constructSignature)
+ Type *Checker::CreateTupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+                                uint32_t minLength, uint32_t fixedLength, bool readonly)
+ {
+-    desc->stringIndexInfo = allocator_->New<IndexInfo>(GlobalAnyType(), "x");
++    desc->string_index_info_ = allocator_->New<IndexInfo>(GlobalAnyType(), "x");
+ 
+     auto *tupleType =
+         allocator_->New<TupleType>(desc, std::move(elementFlags), combinedFlags, minLength, fixedLength, readonly);
+@@ -106,7 +106,7 @@ Type *Checker::CreateTupleType(ObjectDescriptor *desc, TupleElementFlagPool &&el
+                                uint32_t minLength, uint32_t fixedLength, bool readonly,
+                                NamedTupleMemberPool &&namedMembers)
+ {
+-    desc->stringIndexInfo = allocator_->New<IndexInfo>(GlobalAnyType(), "x");
++    desc->string_index_info_ = allocator_->New<IndexInfo>(GlobalAnyType(), "x");
+     ObjectType *tupleType = nullptr;
+ 
+     if (!namedMembers.empty()) {
+diff --git a/typescript/core/typeElaboration.cpp b/typescript/core/typeElaboration.cpp
+index 61cd7c2..322c117 100644
+--- a/typescript/core/typeElaboration.cpp
++++ b/typescript/core/typeElaboration.cpp
+@@ -82,7 +82,7 @@ bool Checker::ElaborateObjectLiteral(TypeOrNode source, const Type *targetType,
+     }
+ 
+     ObjectLiteralElaborationData elaborationData;
+-    elaborationData.desc = allocator_->New<ObjectDescriptor>();
++    elaborationData.desc_ = allocator_->New<ObjectDescriptor>();
+     GetPotentialTypesAndIndexInfosForElaboration(targetType, &elaborationData);
+ 
+     if (sourceNode) {
+@@ -92,11 +92,11 @@ bool Checker::ElaborateObjectLiteral(TypeOrNode source, const Type *targetType,
+         }
+ 
+         if (excessCheckNeeded) {
+-            for (const auto *it : elaborationData.spreads) {
+-                HandleSpreadElement(it->AsSpreadElement(), elaborationData.desc, it->Start());
++            for (const auto *it : elaborationData.spreads_) {
++                HandleSpreadElement(it->AsSpreadElement(), elaborationData.desc_, it->Start());
+             }
+ 
+-            Type *sourceObjType = allocator_->New<ObjectLiteralType>(elaborationData.desc);
++            Type *sourceObjType = allocator_->New<ObjectLiteralType>(elaborationData.desc_);
+ 
+             IsTypeAssignableTo(sourceObjType, targetType,
+                                {"Type '", sourceObjType, "' is not assignable to type '", targetType, "'."}, locInfo);
+@@ -106,7 +106,7 @@ bool Checker::ElaborateObjectLiteral(TypeOrNode source, const Type *targetType,
+     }
+ 
+     ASSERT(sourceType);
+-    ElaborateObjectLiteralWithType(sourceType, targetType, elaborationData.potentialObjectTypes, locInfo);
++    ElaborateObjectLiteralWithType(sourceType, targetType, elaborationData.potential_object_types_, locInfo);
+ 
+     return true;
+ }
+@@ -130,7 +130,7 @@ void Checker::GetPotentialTypesAndIndexInfosForElaboration(const Type *targetTyp
+                     numberInfoTypes.push_back(infoTypePair.second);
+                 }
+ 
+-                elaborationData->potentialObjectTypes.insert({it->Id(), it->AsObjectType()});
++                elaborationData->potential_object_types_.insert({it->Id(), it->AsObjectType()});
+             }
+         }
+ 
+@@ -144,13 +144,13 @@ void Checker::GetPotentialTypesAndIndexInfosForElaboration(const Type *targetTyp
+             stringInfosType = CreateUnionType(std::move(stringInfoTypes));
+         }
+ 
+-        elaborationData->numberInfosType = numberInfosType;
+-        elaborationData->stringInfosType = stringInfosType;
++        elaborationData->number_infos_type_ = numberInfosType;
++        elaborationData->string_infos_type_ = stringInfosType;
+     } else {
+         IndexInfoTypePair infoTypePair = GetIndexInfoTypePair(targetType->AsObjectType());
+ 
+-        elaborationData->stringInfosType = infoTypePair.first;
+-        elaborationData->numberInfosType = infoTypePair.second;
++        elaborationData->string_infos_type_ = infoTypePair.first;
++        elaborationData->number_infos_type_ = infoTypePair.second;
+     }
+ }
+ 
+@@ -177,7 +177,7 @@ bool Checker::CheckIfExcessTypeCheckNeededForObjectElaboration(const Type *targe
+                                                                ObjectLiteralElaborationData *elaborationData)
+ {
+     if (targetType->IsUnionType()) {
+-        for (auto it : elaborationData->potentialObjectTypes) {
++        for (auto it : elaborationData->potential_object_types_) {
+             if (!it.second->CallSignatures().empty() || !it.second->ConstructSignatures().empty()) {
+                 return true;
+             }
+@@ -190,7 +190,7 @@ bool Checker::CheckIfExcessTypeCheckNeededForObjectElaboration(const Type *targe
+     if (targetType->IsUnionType()) {
+         uint32_t targetPropCount = 0;
+ 
+-        for (auto it : elaborationData->potentialObjectTypes) {
++        for (auto it : elaborationData->potential_object_types_) {
+             targetPropCount = it.second->Properties().size();
+ 
+             if (it.second->IsInterfaceType()) {
+@@ -199,7 +199,7 @@ bool Checker::CheckIfExcessTypeCheckNeededForObjectElaboration(const Type *targe
+                 targetPropCount += interfaceProperties.size();
+             }
+ 
+-            if (elaborationData->desc->properties.size() < targetPropCount) {
++            if (elaborationData->desc_->properties_.size() < targetPropCount) {
+                 return true;
+             }
+         }
+@@ -212,7 +212,7 @@ bool Checker::CheckIfExcessTypeCheckNeededForObjectElaboration(const Type *targe
+             targetPropCount += interfaceProperties.size();
+         }
+ 
+-        if (elaborationData->desc->properties.size() < targetPropCount) {
++        if (elaborationData->desc_->properties_.size() < targetPropCount) {
+             return true;
+         }
+     }
+@@ -228,15 +228,15 @@ bool Checker::ElaborateObjectLiteralWithNode(const ir::ObjectExpression *sourceN
+     for (auto *sourceProp : sourceNode->Properties()) {
+         if (!sourceProp->IsProperty()) {
+             ASSERT(sourceProp->IsSpreadElement());
+-            elaborationData->spreads.push_back(sourceProp->AsSpreadElement());
++            elaborationData->spreads_.push_back(sourceProp->AsSpreadElement());
+             excessCheckNeeded = true;
+             continue;
+         }
+         const ir::Property *currentProp = sourceProp->AsProperty();
+ 
+         ObjectLiteralPropertyInfo propInfo =
+-            HandleObjectLiteralProperty(currentProp, elaborationData->desc, &elaborationData->stringIndexTypes);
+-        if (propInfo.handleNextProp) {
++            HandleObjectLiteralProperty(currentProp, elaborationData->desc_, &elaborationData->string_index_types_);
++        if (propInfo.handle_next_prop_) {
+             excessCheckNeeded = true;
+             continue;
+         }
+@@ -244,38 +244,38 @@ bool Checker::ElaborateObjectLiteralWithNode(const ir::ObjectExpression *sourceN
+         bool numberLiteralName = currentProp->Key()->IsNumberLiteral();
+ 
+         Type *targetPropType = GetTargetPropertyTypeFromTargetForElaborationWithNode(
+-            targetType, elaborationData, propInfo.propName, currentProp->Value());
++            targetType, elaborationData, propInfo.prop_name_, currentProp->Value());
+ 
+         if (!targetPropType) {
+             targetPropType =
+-                GetindexInfoTypeOrThrowError(targetType, elaborationData, propInfo.propName, currentProp->IsComputed(),
+-                                             numberLiteralName, sourceProp->Start());
++                GetindexInfoTypeOrThrowError(targetType, elaborationData, propInfo.prop_name_,
++                                             currentProp->IsComputed(), numberLiteralName, sourceProp->Start());
+         }
+ 
+         if (!IsLiteralType(targetPropType) || targetPropType->IsBooleanType()) {
+-            propInfo.propType = GetBaseTypeOfLiteralType(propInfo.propType);
++            propInfo.prop_type_ = GetBaseTypeOfLiteralType(propInfo.prop_type_);
+         }
+ 
+         if (!ElaborateElementwise(currentProp->Value(), targetPropType, sourceProp->Start()) &&
+-            !IsTypeAssignableTo(propInfo.propType, targetPropType)) {
++            !IsTypeAssignableTo(propInfo.prop_type_, targetPropType)) {
+             if (currentProp->IsComputed() && currentProp->Key()->IsIdentifier()) {
+-                ThrowTypeError({"Type of computed property's value is '", propInfo.propType,
++                ThrowTypeError({"Type of computed property's value is '", propInfo.prop_type_,
+                                 "', which is not assignable to type '", targetPropType, "'."},
+                                sourceProp->Start());
+             } else {
+-                ThrowTypeError({"Type '", propInfo.propType, "' is not assignable to type '", targetPropType, "'."},
++                ThrowTypeError({"Type '", propInfo.prop_type_, "' is not assignable to type '", targetPropType, "'."},
+                                sourceProp->Start());
+             }
+         }
+ 
+         auto *objLitProp =
+-            binder::Scope::CreateVar(allocator_, propInfo.propName, binder::VariableFlags::NONE, currentProp);
++            binder::Scope::CreateVar(allocator_, propInfo.prop_name_, binder::VariableFlags::NONE, currentProp);
+ 
+         objLitProp->AddFlag(currentProp->IsMethod() ? binder::VariableFlags::METHOD : binder::VariableFlags::PROPERTY);
+-        propInfo.propType->SetVariable(objLitProp);
+-        propInfo.propType->AddTypeFlag(TypeFlag::RELATION_CHECKED);
+-        objLitProp->SetTsType(propInfo.propType);
+-        elaborationData->desc->properties.push_back(objLitProp);
++        propInfo.prop_type_->SetVariable(objLitProp);
++        propInfo.prop_type_->AddTypeFlag(TypeFlag::RELATION_CHECKED);
++        objLitProp->SetTsType(propInfo.prop_type_);
++        elaborationData->desc_->properties_.push_back(objLitProp);
+     }
+ 
+     return excessCheckNeeded;
+@@ -285,8 +285,8 @@ Type *Checker::GetindexInfoTypeOrThrowError(const Type *targetType, ObjectLitera
+                                             const util::StringView &propName, bool computed, bool numberLiteralName,
+                                             lexer::SourcePosition locInfo)
+ {
+-    if ((!elaborationData->stringInfosType && !elaborationData->numberInfosType) ||
+-        (!numberLiteralName && !elaborationData->stringInfosType)) {
++    if ((!elaborationData->string_infos_type_ && !elaborationData->number_infos_type_) ||
++        (!numberLiteralName && !elaborationData->string_infos_type_)) {
+         std::stringstream ss;
+         if (computed) {
+             ss << "[" << propName << "]";
+@@ -301,11 +301,11 @@ Type *Checker::GetindexInfoTypeOrThrowError(const Type *targetType, ObjectLitera
+                        locInfo);
+     }
+ 
+-    if (numberLiteralName && elaborationData->numberInfosType) {
+-        return elaborationData->numberInfosType;
++    if (numberLiteralName && elaborationData->number_infos_type_) {
++        return elaborationData->number_infos_type_;
+     }
+ 
+-    return elaborationData->stringInfosType;
++    return elaborationData->string_infos_type_;
+ }
+ 
+ void Checker::ElaborateObjectLiteralWithType(const ObjectLiteralType *sourceType, const Type *targetType,
+@@ -341,8 +341,8 @@ Type *Checker::GetTargetPropertyTypeFromTargetForElaborationWithNode(const Type
+ 
+     if (targetType->IsUnionType()) {
+         std::vector<Type *> targetPropTypes;
+-        for (auto potentialType = elaborationData->potentialObjectTypes.begin();
+-             potentialType != elaborationData->potentialObjectTypes.end();) {
++        for (auto potentialType = elaborationData->potential_object_types_.begin();
++             potentialType != elaborationData->potential_object_types_.end();) {
+             searchProp = potentialType->second->GetProperty(propName);
+             if (searchProp) {
+                 if (searchProp->TsType()->IsUnionType()) {
+@@ -354,7 +354,7 @@ Type *Checker::GetTargetPropertyTypeFromTargetForElaborationWithNode(const Type
+                 }
+ 
+                 if (!IsTypeAssignableTo(CreateTupleTypeFromEveryArrayExpression(propValue), searchProp->TsType())) {
+-                    potentialType = elaborationData->potentialObjectTypes.erase(potentialType);
++                    potentialType = elaborationData->potential_object_types_.erase(potentialType);
+                     continue;
+                 }
+ 
+@@ -362,7 +362,7 @@ Type *Checker::GetTargetPropertyTypeFromTargetForElaborationWithNode(const Type
+                 continue;
+             }
+ 
+-            potentialType = elaborationData->potentialObjectTypes.erase(potentialType);
++            potentialType = elaborationData->potential_object_types_.erase(potentialType);
+         }
+ 
+         if (targetPropTypes.empty()) {
+@@ -676,7 +676,7 @@ Type *Checker::GetUnaryResultType(Type *operandType)
+ 
+ Type *Checker::InferVariableDeclarationType(const ir::Identifier *decl)
+ {
+-    if (!typeStack_.insert(decl).second) {
++    if (!type_stack_.insert(decl).second) {
+         if (decl->TypeAnnotation()) {
+             ThrowTypeError({"'", decl->Name(),
+                             "' is referenced directly or indirectly in its "
+diff --git a/typescript/types/constructorType.cpp b/typescript/types/constructorType.cpp
+index a4e91da..f87c9d4 100644
+--- a/typescript/types/constructorType.cpp
++++ b/typescript/types/constructorType.cpp
+@@ -23,18 +23,18 @@ ConstructorType::ConstructorType(ObjectDescriptor *desc) : ObjectType(ObjectType
+ 
+ void ConstructorType::ToString(std::stringstream &ss) const
+ {
+-    if (desc_->constructSignatures.size() > 1) {
++    if (desc_->construct_signatures_.size() > 1) {
+         ss << "{ ";
+     }
+ 
+-    for (auto it = desc_->constructSignatures.begin(); it != desc_->constructSignatures.end(); it++) {
++    for (auto it = desc_->construct_signatures_.begin(); it != desc_->construct_signatures_.end(); it++) {
+         (*it)->ToString(ss, variable_);
+-        if (std::next(it) != desc_->constructSignatures.end()) {
++        if (std::next(it) != desc_->construct_signatures_.end()) {
+             ss << ", ";
+         }
+     }
+ 
+-    if (desc_->constructSignatures.size() > 1) {
++    if (desc_->construct_signatures_.size() > 1) {
+         ss << " }";
+     }
+ }
+diff --git a/typescript/types/enumType.cpp b/typescript/types/enumType.cpp
+index 040b2b3..ed42501 100644
+--- a/typescript/types/enumType.cpp
++++ b/typescript/types/enumType.cpp
+@@ -20,23 +20,23 @@
+ namespace panda::es2panda::checker {
+ 
+ EnumType::EnumType(binder::Variable *enumLiteralVar, binder::EnumVariable *enumVar)
+-    : Type(TypeFlag::ENUM), enumLiteralVar_(enumLiteralVar), enumVar_(enumVar)
++    : Type(TypeFlag::ENUM), enum_literal_var_(enumLiteralVar), enum_var_(enumVar)
+ {
+ }
+ 
+ const binder::Variable *EnumType::EnumLiteralVar() const
+ {
+-    return enumLiteralVar_;
++    return enum_literal_var_;
+ }
+ 
+ const binder::EnumVariable *EnumType::EnumVar() const
+ {
+-    return enumVar_;
++    return enum_var_;
+ }
+ 
+ void EnumType::ToString(std::stringstream &ss) const
+ {
+-    ss << enumLiteralVar_->Name() << "." << enumVar_->Name();
++    ss << enum_literal_var_->Name() << "." << enum_var_->Name();
+ }
+ 
+ void EnumType::Identical([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *other) const
+diff --git a/typescript/types/enumType.h b/typescript/types/enumType.h
+index 1038eba..b16e3af 100644
+--- a/typescript/types/enumType.h
++++ b/typescript/types/enumType.h
+@@ -38,8 +38,8 @@ public:
+     Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+ 
+ private:
+-    binder::Variable *enumLiteralVar_;
+-    binder::EnumVariable *enumVar_;
++    binder::Variable *enum_literal_var_;
++    binder::EnumVariable *enum_var_;
+ };
+ 
+ }  // namespace panda::es2panda::checker
+diff --git a/typescript/types/functionType.cpp b/typescript/types/functionType.cpp
+index bdad12e..b788615 100644
+--- a/typescript/types/functionType.cpp
++++ b/typescript/types/functionType.cpp
+@@ -33,18 +33,18 @@ void FunctionType::ToString(std::stringstream &ss) const
+ 
+     stack.insert(this);
+ 
+-    if (desc_->callSignatures.size() > 1) {
++    if (desc_->call_signatures_.size() > 1) {
+         ss << "{ ";
+     }
+ 
+-    for (auto it = desc_->callSignatures.begin(); it != desc_->callSignatures.end(); it++) {
+-        (*it)->ToString(ss, variable_, desc_->callSignatures.size() > 1);
+-        if (std::next(it) != desc_->callSignatures.end()) {
++    for (auto it = desc_->call_signatures_.begin(); it != desc_->call_signatures_.end(); it++) {
++        (*it)->ToString(ss, variable_, desc_->call_signatures_.size() > 1);
++        if (std::next(it) != desc_->call_signatures_.end()) {
+             ss << ", ";
+         }
+     }
+ 
+-    if (desc_->callSignatures.size() > 1) {
++    if (desc_->call_signatures_.size() > 1) {
+         ss << " }";
+     }
+ }
+diff --git a/typescript/types/globalTypesHolder.cpp b/typescript/types/globalTypesHolder.cpp
+index c944b94..4069d25 100644
+--- a/typescript/types/globalTypesHolder.cpp
++++ b/typescript/types/globalTypesHolder.cpp
+@@ -38,136 +38,136 @@ namespace panda::es2panda::checker {
+ 
+ GlobalTypesHolder::GlobalTypesHolder(ArenaAllocator *allocator)
+ {
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER)] = allocator->New<NumberType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::ANY)] = allocator->New<AnyType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::STRING)] = allocator->New<StringType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::BOOLEAN)] = allocator->New<BooleanType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::VOID)] = allocator->New<VoidType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::NULL_ID)] = allocator->New<NullType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::UNDEFINED)] = allocator->New<UndefinedType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::UNKNOWN)] = allocator->New<UnknownType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::NEVER)] = allocator->New<NeverType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE)] = allocator->New<NonPrimitiveType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::BIGINT)] = allocator->New<BigintType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::FALSE_ID)] = allocator->New<BooleanLiteralType>(false);
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::TRUE_ID)] = allocator->New<BooleanLiteralType>(true);
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT)] =
++    global_types_[static_cast<size_t>(GlobalTypeId::NUMBER)] = allocator->New<NumberType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::ANY)] = allocator->New<AnyType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::STRING)] = allocator->New<StringType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::BOOLEAN)] = allocator->New<BooleanType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::VOID)] = allocator->New<VoidType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::NULL_ID)] = allocator->New<NullType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::UNDEFINED)] = allocator->New<UndefinedType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::UNKNOWN)] = allocator->New<UnknownType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::NEVER)] = allocator->New<NeverType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE)] = allocator->New<NonPrimitiveType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::BIGINT)] = allocator->New<BigintType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::FALSE_ID)] = allocator->New<BooleanLiteralType>(false);
++    global_types_[static_cast<size_t>(GlobalTypeId::TRUE_ID)] = allocator->New<BooleanLiteralType>(true);
++    global_types_[static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT)] =
+         allocator->New<UnionType>(std::initializer_list<Type *> {GlobalNumberType(), GlobalBigintType()});
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER)] =
++    global_types_[static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER)] =
+         allocator->New<UnionType>(std::initializer_list<Type *> {GlobalStringType(), GlobalNumberType()});
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO)] = allocator->New<NumberLiteralType>(0);
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_STRING)] = allocator->New<StringLiteralType>("");
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO_BIGINT)] = allocator->New<BigintLiteralType>("0n", false);
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::PRIMITIVE)] = allocator->New<UnionType>(
++    global_types_[static_cast<size_t>(GlobalTypeId::ZERO)] = allocator->New<NumberLiteralType>(0);
++    global_types_[static_cast<size_t>(GlobalTypeId::EMPTY_STRING)] = allocator->New<StringLiteralType>("");
++    global_types_[static_cast<size_t>(GlobalTypeId::ZERO_BIGINT)] = allocator->New<BigintLiteralType>("0n", false);
++    global_types_[static_cast<size_t>(GlobalTypeId::PRIMITIVE)] = allocator->New<UnionType>(
+         std::initializer_list<Type *> {GlobalNumberType(), GlobalStringType(), GlobalBigintType(), GlobalBooleanType(),
+                                        GlobalVoidType(), GlobalUndefinedType(), GlobalNullType()});
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE)] = allocator->New<TupleType>();
+-    globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT)] = allocator->New<ObjectLiteralType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE)] = allocator->New<TupleType>();
++    global_types_[static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT)] = allocator->New<ObjectLiteralType>();
+ }
+ 
+ Type *GlobalTypesHolder::GlobalNumberType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::NUMBER));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalAnyType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ANY));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::ANY));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalStringType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::STRING));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalBooleanType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BOOLEAN));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::BOOLEAN));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalVoidType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::VOID));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::VOID));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalNullType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NULL_ID));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::NULL_ID));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalUndefinedType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNDEFINED));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::UNDEFINED));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalUnknownType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNKNOWN));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::UNKNOWN));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalNeverType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NEVER));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::NEVER));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalNonPrimitiveType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalBigintType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BIGINT));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::BIGINT));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalFalseType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::FALSE_ID));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::FALSE_ID));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalTrueType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::TRUE_ID));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::TRUE_ID));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalNumberOrBigintType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalStringOrNumberType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalZeroType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::ZERO));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalEmptyStringType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_STRING));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::EMPTY_STRING));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalZeroBigintType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO_BIGINT));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::ZERO_BIGINT));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalPrimitiveType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::PRIMITIVE));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::PRIMITIVE));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalEmptyTupleType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE));
+ }
+ 
+ Type *GlobalTypesHolder::GlobalEmptyObjectType()
+ {
+-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT));
++    return global_types_.at(static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT));
+ }
+ 
+ }  // namespace panda::es2panda::checker
+diff --git a/typescript/types/globalTypesHolder.h b/typescript/types/globalTypesHolder.h
+index 83fb925..f4810eb 100644
+--- a/typescript/types/globalTypesHolder.h
++++ b/typescript/types/globalTypesHolder.h
+@@ -75,7 +75,7 @@ public:
+     Type *GlobalEmptyObjectType();
+ 
+ private:
+-    std::array<Type *, static_cast<size_t>(GlobalTypeId::COUNT)> globalTypes_ {};
++    std::array<Type *, static_cast<size_t>(GlobalTypeId::COUNT)> global_types_ {};
+ };
+ 
+ }  // namespace panda::es2panda::checker
+diff --git a/typescript/types/indexInfo.cpp b/typescript/types/indexInfo.cpp
+index 5aad2d1..6d9078e 100644
+--- a/typescript/types/indexInfo.cpp
++++ b/typescript/types/indexInfo.cpp
+@@ -20,7 +20,7 @@
+ namespace panda::es2panda::checker {
+ 
+ IndexInfo::IndexInfo(Type *type, util::StringView paramName, bool readonly)
+-    : type_(type), paramName_(paramName), readonly_(readonly)
++    : type_(type), param_name_(paramName), readonly_(readonly)
+ {
+ }
+ 
+@@ -41,12 +41,12 @@ void IndexInfo::SetInfoType(class Type *type)
+ 
+ const util::StringView &IndexInfo::ParamName()
+ {
+-    return paramName_;
++    return param_name_;
+ }
+ 
+ IndexInfo *IndexInfo::Copy(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+ {
+-    return allocator->New<IndexInfo>(type_->Instantiate(allocator, relation, globalTypes), paramName_, readonly_);
++    return allocator->New<IndexInfo>(type_->Instantiate(allocator, relation, globalTypes), param_name_, readonly_);
+ }
+ 
+ void IndexInfo::ToString(std::stringstream &ss, bool numIndex) const
+@@ -55,7 +55,7 @@ void IndexInfo::ToString(std::stringstream &ss, bool numIndex) const
+         ss << "readonly ";
+     }
+ 
+-    ss << "[" << paramName_ << ": ";
++    ss << "[" << param_name_ << ": ";
+ 
+     if (numIndex) {
+         ss << "number]: ";
+diff --git a/typescript/types/indexInfo.h b/typescript/types/indexInfo.h
+index c20ee43..3f67bff 100644
+--- a/typescript/types/indexInfo.h
++++ b/typescript/types/indexInfo.h
+@@ -40,7 +40,7 @@ public:
+ 
+ private:
+     Type *type_;
+-    util::StringView paramName_;
++    util::StringView param_name_;
+     bool readonly_;
+ };
+ 
+diff --git a/typescript/types/interfaceType.cpp b/typescript/types/interfaceType.cpp
+index 8f1fbb3..01ea0ca 100644
+--- a/typescript/types/interfaceType.cpp
++++ b/typescript/types/interfaceType.cpp
+@@ -45,22 +45,22 @@ const util::StringView &InterfaceType::Name() const
+ 
+ void InterfaceType::SetMergedTypeParams(std::pair<std::vector<binder::Variable *>, size_t> &&mergedTypeParams)
+ {
+-    mergedTypeParams_ = std::move(mergedTypeParams);
++    merged_type_params_ = std::move(mergedTypeParams);
+ }
+ 
+ const std::pair<std::vector<binder::Variable *>, size_t> &InterfaceType::GetMergedTypeParams() const
+ {
+-    return mergedTypeParams_;
++    return merged_type_params_;
+ }
+ 
+ void InterfaceType::SetTypeParamTypes(std::vector<Type *> &&typeParamTypes)
+ {
+-    typeParamTypes_ = std::move(typeParamTypes);
++    type_param_types_ = std::move(typeParamTypes);
+ }
+ 
+ const std::vector<Type *> &InterfaceType::GetTypeParamTypes() const
+ {
+-    return typeParamTypes_;
++    return type_param_types_;
+ }
+ 
+ binder::LocalVariable *InterfaceType::GetProperty(const util::StringView &name) const
+@@ -85,13 +85,13 @@ void InterfaceType::ToString(std::stringstream &ss) const
+ {
+     ss << name_;
+ 
+-    if (!typeParamTypes_.empty()) {
++    if (!type_param_types_.empty()) {
+         ss << "<";
+ 
+-        for (auto it = typeParamTypes_.begin(); it != typeParamTypes_.end(); it++) {
++        for (auto it = type_param_types_.begin(); it != type_param_types_.end(); it++) {
+             (*it)->ToString(ss);
+ 
+-            if (std::next(it) != typeParamTypes_.end()) {
++            if (std::next(it) != type_param_types_.end()) {
+                 ss << ", ";
+             }
+         }
+@@ -281,8 +281,8 @@ IndexInfo *InterfaceType::FindIndexInfo(bool findNumberInfo)
+ 
+ TypeFacts InterfaceType::GetTypeFacts() const
+ {
+-    if (desc_->properties.empty() && desc_->callSignatures.empty() && desc_->constructSignatures.empty() &&
+-        !desc_->stringIndexInfo && !desc_->numberIndexInfo) {
++    if (desc_->properties_.empty() && desc_->call_signatures_.empty() && desc_->construct_signatures_.empty() &&
++        !desc_->string_index_info_ && !desc_->number_index_info_) {
+         if (bases_.empty()) {
+             return TypeFacts::EMPTY_OBJECT_FACTS;
+         }
+diff --git a/typescript/types/interfaceType.h b/typescript/types/interfaceType.h
+index f46f395..d2b3bca 100644
+--- a/typescript/types/interfaceType.h
++++ b/typescript/types/interfaceType.h
+@@ -46,8 +46,8 @@ public:
+ private:
+     util::StringView name_;
+     std::vector<ObjectType *> bases_;
+-    std::pair<std::vector<binder::Variable *>, size_t> mergedTypeParams_ {};
+-    std::vector<Type *> typeParamTypes_ {};
++    std::pair<std::vector<binder::Variable *>, size_t> merged_type_params_ {};
++    std::vector<Type *> type_param_types_ {};
+ };
+ 
+ }  // namespace panda::es2panda::checker
+diff --git a/typescript/types/objectDescriptor.cpp b/typescript/types/objectDescriptor.cpp
+index 6c1d600..e2515d9 100644
+--- a/typescript/types/objectDescriptor.cpp
++++ b/typescript/types/objectDescriptor.cpp
+@@ -23,7 +23,7 @@ namespace panda::es2panda::checker {
+ 
+ binder::LocalVariable *ObjectDescriptor::FindProperty(const util::StringView &name) const
+ {
+-    for (auto *it : properties) {
++    for (auto *it : properties_) {
+         if (it->Name() == name) {
+             return it;
+         }
+@@ -34,46 +34,46 @@ binder::LocalVariable *ObjectDescriptor::FindProperty(const util::StringView &na
+ 
+ ObjectDescriptor::~ObjectDescriptor()
+ {
+-    for (auto *it : properties) {
++    for (auto *it : properties_) {
+         delete it;
+     }
+ 
+-    for (auto *it : callSignatures) {
++    for (auto *it : call_signatures_) {
+         delete it;
+     }
+ 
+-    for (auto *it : constructSignatures) {
++    for (auto *it : construct_signatures_) {
+         delete it;
+     }
+ 
+-    delete stringIndexInfo;
+-    delete numberIndexInfo;
++    delete string_index_info_;
++    delete number_index_info_;
+ }
+ 
+ void ObjectDescriptor::Copy(ArenaAllocator *allocator, ObjectDescriptor *copiedDesc, TypeRelation *relation,
+                             GlobalTypesHolder *globalTypes)
+ {
+     // kézzel másolás
+-    for (auto *it : properties) {
++    for (auto *it : properties_) {
+         auto *copiedProp = it->Copy(allocator, it->Declaration());
+         copiedProp->SetTsType(it->TsType()->Instantiate(allocator, relation, globalTypes));
+-        copiedDesc->properties.push_back(copiedProp);
++        copiedDesc->properties_.push_back(copiedProp);
+     }
+ 
+-    for (auto *it : callSignatures) {
+-        copiedDesc->callSignatures.push_back(it->Copy(allocator, relation, globalTypes));
++    for (auto *it : call_signatures_) {
++        copiedDesc->call_signatures_.push_back(it->Copy(allocator, relation, globalTypes));
+     }
+ 
+-    for (auto *it : constructSignatures) {
+-        copiedDesc->constructSignatures.push_back(it->Copy(allocator, relation, globalTypes));
++    for (auto *it : construct_signatures_) {
++        copiedDesc->construct_signatures_.push_back(it->Copy(allocator, relation, globalTypes));
+     }
+ 
+-    if (numberIndexInfo) {
+-        copiedDesc->numberIndexInfo = numberIndexInfo->Copy(allocator, relation, globalTypes);
++    if (number_index_info_) {
++        copiedDesc->number_index_info_ = number_index_info_->Copy(allocator, relation, globalTypes);
+     }
+ 
+-    if (stringIndexInfo) {
+-        copiedDesc->stringIndexInfo = stringIndexInfo->Copy(allocator, relation, globalTypes);
++    if (string_index_info_) {
++        copiedDesc->string_index_info_ = string_index_info_->Copy(allocator, relation, globalTypes);
+     }
+ }
+ 
+diff --git a/typescript/types/objectDescriptor.h b/typescript/types/objectDescriptor.h
+index 0ac489f..e43b350 100644
+--- a/typescript/types/objectDescriptor.h
++++ b/typescript/types/objectDescriptor.h
+@@ -43,11 +43,11 @@ public:
+     void Copy(ArenaAllocator *allocator, ObjectDescriptor *copiedDesc, TypeRelation *relation,
+               GlobalTypesHolder *globalTypes);
+ 
+-    std::vector<binder::LocalVariable *> properties {};
+-    std::vector<Signature *> callSignatures {};
+-    std::vector<Signature *> constructSignatures {};
+-    IndexInfo *stringIndexInfo {nullptr};
+-    IndexInfo *numberIndexInfo {nullptr};
++    std::vector<binder::LocalVariable *> properties_ {};
++    std::vector<Signature *> call_signatures_ {};
++    std::vector<Signature *> construct_signatures_ {};
++    IndexInfo *string_index_info_ {nullptr};
++    IndexInfo *number_index_info_ {nullptr};
+ };
+ 
+ }  // namespace panda::es2panda::checker
+diff --git a/typescript/types/objectLiteralType.cpp b/typescript/types/objectLiteralType.cpp
+index ccdd18d..f19e02a 100644
+--- a/typescript/types/objectLiteralType.cpp
++++ b/typescript/types/objectLiteralType.cpp
+@@ -30,28 +30,28 @@ void ObjectLiteralType::ToString(std::stringstream &ss) const
+ {
+     ss << "{ ";
+ 
+-    if (desc_->stringIndexInfo) {
+-        desc_->stringIndexInfo->ToString(ss, false);
++    if (desc_->string_index_info_) {
++        desc_->string_index_info_->ToString(ss, false);
+         ss << "; ";
+     }
+ 
+-    if (desc_->numberIndexInfo) {
+-        desc_->numberIndexInfo->ToString(ss, true);
++    if (desc_->number_index_info_) {
++        desc_->number_index_info_->ToString(ss, true);
+         ss << "; ";
+     }
+ 
+-    for (auto *it : desc_->callSignatures) {
++    for (auto *it : desc_->call_signatures_) {
+         it->ToString(ss, nullptr, true);
+         ss << "; ";
+     }
+ 
+-    for (auto *it : desc_->constructSignatures) {
++    for (auto *it : desc_->construct_signatures_) {
+         ss << "new ";
+         it->ToString(ss, nullptr, true);
+         ss << "; ";
+     }
+ 
+-    for (auto *it : desc_->properties) {
++    for (auto *it : desc_->properties_) {
+         if (it->HasFlag(binder::VariableFlags::READONLY)) {
+             ss << "readonly ";
+         }
+@@ -72,8 +72,8 @@ void ObjectLiteralType::ToString(std::stringstream &ss) const
+ 
+ TypeFacts ObjectLiteralType::GetTypeFacts() const
+ {
+-    if (desc_->properties.empty() && desc_->callSignatures.empty() && desc_->constructSignatures.empty() &&
+-        !desc_->numberIndexInfo && !desc_->stringIndexInfo) {
++    if (desc_->properties_.empty() && desc_->call_signatures_.empty() && desc_->construct_signatures_.empty() &&
++        !desc_->number_index_info_ && !desc_->string_index_info_) {
+         return TypeFacts::EMPTY_OBJECT_FACTS;
+     }
+ 
+diff --git a/typescript/types/objectType.cpp b/typescript/types/objectType.cpp
+index f70167b..71aae39 100644
+--- a/typescript/types/objectType.cpp
++++ b/typescript/types/objectType.cpp
+@@ -24,12 +24,12 @@
+ namespace panda::es2panda::checker {
+ 
+ ObjectType::ObjectType(ObjectTypeKind kind)
+-    : Type(TypeFlag::OBJECT), kind_(kind), desc_(nullptr), objFlag_(ObjectFlags::CHECK_EXCESS_PROPS)
++    : Type(TypeFlag::OBJECT), kind_(kind), desc_(nullptr), obj_flag_(ObjectFlags::CHECK_EXCESS_PROPS)
+ {
+ }
+ 
+ ObjectType::ObjectType(ObjectTypeKind kind, ObjectDescriptor *desc)
+-    : Type(TypeFlag::OBJECT), kind_(kind), desc_(desc), objFlag_(ObjectFlags::CHECK_EXCESS_PROPS)
++    : Type(TypeFlag::OBJECT), kind_(kind), desc_(desc), obj_flag_(ObjectFlags::CHECK_EXCESS_PROPS)
+ {
+ }
+ 
+@@ -40,42 +40,42 @@ ObjectType::ObjectTypeKind ObjectType::Kind() const
+ 
+ std::vector<Signature *> &ObjectType::CallSignatures()
+ {
+-    return desc_->callSignatures;
++    return desc_->call_signatures_;
+ }
+ 
+ const std::vector<Signature *> &ObjectType::CallSignatures() const
+ {
+-    return desc_->callSignatures;
++    return desc_->call_signatures_;
+ }
+ 
+ const std::vector<Signature *> &ObjectType::ConstructSignatures() const
+ {
+-    return desc_->constructSignatures;
++    return desc_->construct_signatures_;
+ }
+ 
+ const IndexInfo *ObjectType::StringIndexInfo() const
+ {
+-    return desc_->stringIndexInfo;
++    return desc_->string_index_info_;
+ }
+ 
+ const IndexInfo *ObjectType::NumberIndexInfo() const
+ {
+-    return desc_->numberIndexInfo;
++    return desc_->number_index_info_;
+ }
+ 
+ IndexInfo *ObjectType::StringIndexInfo()
+ {
+-    return desc_->stringIndexInfo;
++    return desc_->string_index_info_;
+ }
+ 
+ IndexInfo *ObjectType::NumberIndexInfo()
+ {
+-    return desc_->numberIndexInfo;
++    return desc_->number_index_info_;
+ }
+ 
+ const std::vector<binder::LocalVariable *> &ObjectType::Properties() const
+ {
+-    return desc_->properties;
++    return desc_->properties_;
+ }
+ 
+ ObjectDescriptor *ObjectType::Desc()
+@@ -90,12 +90,12 @@ const ObjectDescriptor *ObjectType::Desc() const
+ 
+ void ObjectType::AddProperty(binder::LocalVariable *prop)
+ {
+-    desc_->properties.push_back(prop);
++    desc_->properties_.push_back(prop);
+ }
+ 
+ binder::LocalVariable *ObjectType::GetProperty(const util::StringView &name) const
+ {
+-    for (auto *it : desc_->properties) {
++    for (auto *it : desc_->properties_) {
+         if (name == it->Name()) {
+             return it;
+         }
+@@ -107,25 +107,25 @@ binder::LocalVariable *ObjectType::GetProperty(const util::StringView &name) con
+ void ObjectType::AddSignature(Signature *signature, bool isCall)
+ {
+     if (isCall) {
+-        desc_->callSignatures.push_back(signature);
++        desc_->call_signatures_.push_back(signature);
+     } else {
+-        desc_->constructSignatures.push_back(signature);
++        desc_->construct_signatures_.push_back(signature);
+     }
+ }
+ 
+ void ObjectType::AddObjectFlag(ObjectFlags flag)
+ {
+-    objFlag_ |= flag;
++    obj_flag_ |= flag;
+ }
+ 
+ void ObjectType::RemoveObjectFlag(ObjectFlags flag)
+ {
+-    objFlag_ &= ~flag;
++    obj_flag_ &= ~flag;
+ }
+ 
+ bool ObjectType::HasObjectFlag(ObjectFlags flag) const
+ {
+-    return (objFlag_ & flag) != 0;
++    return (obj_flag_ & flag) != 0;
+ }
+ 
+ bool ObjectType::EachSignatureRelatedToSomeSignature(TypeRelation *relation,
+@@ -163,18 +163,18 @@ void ObjectType::Identical(TypeRelation *relation, const Type *other) const
+ 
+     const ObjectType *otherObj = other->AsObjectType();
+ 
+-    if (desc_->properties.size() != otherObj->Properties().size() ||
++    if (desc_->properties_.size() != otherObj->Properties().size() ||
+         CallSignatures().size() != otherObj->CallSignatures().size() ||
+         ConstructSignatures().size() != otherObj->ConstructSignatures().size() ||
+-        (desc_->numberIndexInfo && !otherObj->NumberIndexInfo()) ||
+-        (!desc_->numberIndexInfo && otherObj->NumberIndexInfo()) ||
+-        (desc_->stringIndexInfo && !otherObj->StringIndexInfo()) ||
+-        (!desc_->stringIndexInfo && otherObj->StringIndexInfo())) {
++        (desc_->number_index_info_ && !otherObj->NumberIndexInfo()) ||
++        (!desc_->number_index_info_ && otherObj->NumberIndexInfo()) ||
++        (desc_->string_index_info_ && !otherObj->StringIndexInfo()) ||
++        (!desc_->string_index_info_ && otherObj->StringIndexInfo())) {
+         relation->Result(false);
+         return;
+     }
+ 
+-    for (auto *it : desc_->properties) {
++    for (auto *it : desc_->properties_) {
+         binder::LocalVariable *found = otherObj->Desc()->FindProperty(it->Name());
+         if (!found) {
+             relation->Result(false);
+@@ -203,15 +203,15 @@ void ObjectType::Identical(TypeRelation *relation, const Type *other) const
+         return;
+     }
+ 
+-    if (desc_->numberIndexInfo) {
+-        relation->IsIdenticalTo(desc_->numberIndexInfo, otherObj->NumberIndexInfo());
++    if (desc_->number_index_info_) {
++        relation->IsIdenticalTo(desc_->number_index_info_, otherObj->NumberIndexInfo());
+         if (!relation->IsTrue()) {
+             return;
+         }
+     }
+ 
+-    if (desc_->stringIndexInfo) {
+-        relation->IsIdenticalTo(desc_->stringIndexInfo, otherObj->StringIndexInfo());
++    if (desc_->string_index_info_) {
++        relation->IsIdenticalTo(desc_->string_index_info_, otherObj->StringIndexInfo());
+         if (!relation->IsTrue()) {
+             return;
+         }
+@@ -230,9 +230,9 @@ void ObjectType::AssignProperties(TypeRelation *relation, const ObjectType *sour
+         numberInfo = this->AsInterfaceType()->FindIndexInfo(true);
+         stringInfo = this->AsInterfaceType()->FindIndexInfo(false);
+     } else {
+-        targetProperties = desc_->properties;
+-        numberInfo = desc_->numberIndexInfo;
+-        stringInfo = desc_->stringIndexInfo;
++        targetProperties = desc_->properties_;
++        numberInfo = desc_->number_index_info_;
++        stringInfo = desc_->string_index_info_;
+     }
+ 
+     for (auto *it : targetProperties) {
+diff --git a/typescript/types/objectType.h b/typescript/types/objectType.h
+index f8ab9c9..a627d7a 100644
+--- a/typescript/types/objectType.h
++++ b/typescript/types/objectType.h
+@@ -113,7 +113,7 @@ public:
+ protected:
+     ObjectTypeKind kind_;
+     ObjectDescriptor *desc_;
+-    ObjectFlags objFlag_;
++    ObjectFlags obj_flag_;
+ };
+ 
+ DEFINE_BITOPS(ObjectType::ObjectFlags)
+diff --git a/typescript/types/signature.cpp b/typescript/types/signature.cpp
+index 2d0568c..e766a84 100644
+--- a/typescript/types/signature.cpp
++++ b/typescript/types/signature.cpp
+@@ -21,71 +21,71 @@ namespace panda::es2panda::checker {
+ 
+ SignatureInfo::SignatureInfo(const SignatureInfo *other, ArenaAllocator *allocator)
+ {
+-    for (auto *it : other->funcParams) {
+-        funcParams.push_back(it->Copy(allocator, it->Declaration()));
++    for (auto *it : other->func_params_) {
++        func_params_.push_back(it->Copy(allocator, it->Declaration()));
+     }
+ 
+-    minArgCount = other->minArgCount;
++    min_arg_count_ = other->min_arg_count_;
+ 
+-    if (other->restVar) {
+-        restVar = other->restVar->Copy(allocator, other->restVar->Declaration());
++    if (other->rest_var_) {
++        rest_var_ = other->rest_var_->Copy(allocator, other->rest_var_->Declaration());
+     }
+ }
+ 
+ Signature::Signature(SignatureInfo *signatureInfo, Type *returnType)
+-    : signatureInfo_(signatureInfo), returnType_(returnType)
++    : signature_info_(signatureInfo), return_type_(returnType)
+ {
+ }
+ 
+ const SignatureInfo *Signature::Info() const
+ {
+-    return signatureInfo_;
++    return signature_info_;
+ }
+ 
+ const std::vector<binder::LocalVariable *> &Signature::Params() const
+ {
+-    return signatureInfo_->funcParams;
++    return signature_info_->func_params_;
+ }
+ 
+ const Type *Signature::ReturnType() const
+ {
+-    return returnType_;
++    return return_type_;
+ }
+ 
+ Type *Signature::ReturnType()
+ {
+-    return returnType_;
++    return return_type_;
+ }
+ 
+ uint32_t Signature::MinArgCount() const
+ {
+-    return signatureInfo_->minArgCount;
++    return signature_info_->min_arg_count_;
+ }
+ 
+ uint32_t Signature::OptionalArgCount() const
+ {
+-    return signatureInfo_->funcParams.size() - signatureInfo_->minArgCount;
++    return signature_info_->func_params_.size() - signature_info_->min_arg_count_;
+ }
+ 
+ void Signature::SetReturnType(Type *type)
+ {
+-    returnType_ = type;
++    return_type_ = type;
+ }
+ 
+ const binder::LocalVariable *Signature::RestVar() const
+ {
+-    return signatureInfo_->restVar;
++    return signature_info_->rest_var_;
+ }
+ 
+ Signature *Signature::Copy(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+ {
+-    SignatureInfo *copiedInfo = allocator->New<checker::SignatureInfo>(signatureInfo_, allocator);
++    SignatureInfo *copiedInfo = allocator->New<checker::SignatureInfo>(signature_info_, allocator);
+ 
+-    for (auto *it : copiedInfo->funcParams) {
++    for (auto *it : copiedInfo->func_params_) {
+         it->SetTsType(it->TsType()->Instantiate(allocator, relation, globalTypes));
+     }
+ 
+-    Type *copiedReturnType = returnType_->Instantiate(allocator, relation, globalTypes);
++    Type *copiedReturnType = return_type_->Instantiate(allocator, relation, globalTypes);
+ 
+     return allocator->New<Signature>(copiedInfo, copiedReturnType);
+ }
+@@ -94,7 +94,7 @@ void Signature::ToString(std::stringstream &ss, const binder::Variable *variable
+ {
+     ss << "(";
+ 
+-    for (auto it = signatureInfo_->funcParams.begin(); it != signatureInfo_->funcParams.end(); it++) {
++    for (auto it = signature_info_->func_params_.begin(); it != signature_info_->func_params_.end(); it++) {
+         ss << (*it)->Name();
+ 
+         if ((*it)->HasFlag(binder::VariableFlags::OPTIONAL)) {
+@@ -105,20 +105,20 @@ void Signature::ToString(std::stringstream &ss, const binder::Variable *variable
+ 
+         (*it)->TsType()->ToString(ss);
+ 
+-        if (std::next(it) != signatureInfo_->funcParams.end()) {
++        if (std::next(it) != signature_info_->func_params_.end()) {
+             ss << ", ";
+         }
+     }
+ 
+-    if (signatureInfo_->restVar) {
+-        if (!signatureInfo_->funcParams.empty()) {
++    if (signature_info_->rest_var_) {
++        if (!signature_info_->func_params_.empty()) {
+             ss << ", ";
+         }
+ 
+         ss << "...";
+-        ss << signatureInfo_->restVar->Name();
++        ss << signature_info_->rest_var_->Name();
+         ss << ": ";
+-        signatureInfo_->restVar->TsType()->ToString(ss);
++        signature_info_->rest_var_->TsType()->ToString(ss);
+         ss << "[]";
+     }
+ 
+@@ -130,30 +130,31 @@ void Signature::ToString(std::stringstream &ss, const binder::Variable *variable
+         ss << " => ";
+     }
+ 
+-    returnType_->ToString(ss);
++    return_type_->ToString(ss);
+ }
+ 
+ void Signature::Identical(TypeRelation *relation, const Signature *other) const
+ {
+-    if (signatureInfo_->minArgCount != other->MinArgCount() ||
+-        signatureInfo_->funcParams.size() != other->Params().size()) {
++    if (signature_info_->min_arg_count_ != other->MinArgCount() ||
++        signature_info_->func_params_.size() != other->Params().size()) {
+         relation->Result(false);
+         return;
+     }
+ 
+-    relation->IsIdenticalTo(returnType_, other->ReturnType());
++    relation->IsIdenticalTo(return_type_, other->ReturnType());
+ 
+     if (relation->IsTrue()) {
+-        for (uint64_t i = 0; i < signatureInfo_->funcParams.size(); i++) {
+-            relation->IsIdenticalTo(signatureInfo_->funcParams[i]->TsType(), other->Params()[i]->TsType());
++        for (uint64_t i = 0; i < signature_info_->func_params_.size(); i++) {
++            relation->IsIdenticalTo(signature_info_->func_params_[i]->TsType(), other->Params()[i]->TsType());
+             if (!relation->IsTrue()) {
+                 return;
+             }
+         }
+ 
+-        if (signatureInfo_->restVar && other->RestVar()) {
+-            relation->IsIdenticalTo(signatureInfo_->restVar->TsType(), other->RestVar()->TsType());
+-        } else if ((signatureInfo_->restVar && !other->RestVar()) || (!signatureInfo_->restVar && other->RestVar())) {
++        if (signature_info_->rest_var_ && other->RestVar()) {
++            relation->IsIdenticalTo(signature_info_->rest_var_->TsType(), other->RestVar()->TsType());
++        } else if ((signature_info_->rest_var_ && !other->RestVar()) ||
++                   (!signature_info_->rest_var_ && other->RestVar())) {
+             relation->Result(false);
+         }
+     }
+@@ -161,19 +162,19 @@ void Signature::Identical(TypeRelation *relation, const Signature *other) const
+ 
+ void Signature::AssignmentTarget(TypeRelation *relation, const Signature *source) const
+ {
+-    if (!signatureInfo_->restVar &&
+-        (source->Params().size() - source->OptionalArgCount()) > signatureInfo_->funcParams.size()) {
++    if (!signature_info_->rest_var_ &&
++        (source->Params().size() - source->OptionalArgCount()) > signature_info_->func_params_.size()) {
+         relation->Result(false);
+         return;
+     }
+ 
+     for (size_t i = 0; i < source->Params().size(); i++) {
+-        if (!signatureInfo_->restVar && i >= Params().size()) {
++        if (!signature_info_->rest_var_ && i >= Params().size()) {
+             break;
+         }
+ 
+-        if (signatureInfo_->restVar) {
+-            relation->IsAssignableTo(source->Params()[i]->TsType(), signatureInfo_->restVar->TsType());
++        if (signature_info_->rest_var_) {
++            relation->IsAssignableTo(source->Params()[i]->TsType(), signature_info_->rest_var_->TsType());
+ 
+             if (!relation->IsTrue()) {
+                 return;
+@@ -191,8 +192,8 @@ void Signature::AssignmentTarget(TypeRelation *relation, const Signature *source
+ 
+     relation->IsAssignableTo(source->ReturnType(), ReturnType());
+ 
+-    if (relation->IsTrue() && signatureInfo_->restVar && source->RestVar()) {
+-        relation->IsAssignableTo(source->RestVar()->TsType(), signatureInfo_->restVar->TsType());
++    if (relation->IsTrue() && signature_info_->rest_var_ && source->RestVar()) {
++        relation->IsAssignableTo(source->RestVar()->TsType(), signature_info_->rest_var_->TsType());
+     }
+ }
+ 
+diff --git a/typescript/types/signature.h b/typescript/types/signature.h
+index 5943e59..6cfacde 100644
+--- a/typescript/types/signature.h
++++ b/typescript/types/signature.h
+@@ -32,9 +32,9 @@ public:
+     NO_MOVE_SEMANTIC(SignatureInfo);
+     ~SignatureInfo() = default;
+ 
+-    uint32_t minArgCount {};
+-    binder::LocalVariable *restVar {};
+-    std::vector<binder::LocalVariable *> funcParams {};
++    uint32_t min_arg_count_ {};
++    binder::LocalVariable *rest_var_ {};
++    std::vector<binder::LocalVariable *> func_params_ {};
+ };
+ 
+ class Signature {
+@@ -59,8 +59,8 @@ public:
+     void AssignmentTarget(TypeRelation *relation, const Signature *source) const;
+ 
+ private:
+-    SignatureInfo *signatureInfo_;
+-    Type *returnType_;
++    SignatureInfo *signature_info_;
++    Type *return_type_;
+ };
+ 
+ }  // namespace panda::es2panda::checker
+diff --git a/typescript/types/tupleType.cpp b/typescript/types/tupleType.cpp
+index d0a8597..1256af7 100644
+--- a/typescript/types/tupleType.cpp
++++ b/typescript/types/tupleType.cpp
+@@ -19,15 +19,15 @@
+ 
+ namespace panda::es2panda::checker {
+ 
+-TupleTypeIterator::TupleTypeIterator(TupleType *tuple) : tupleType_(tuple) {}
++TupleTypeIterator::TupleTypeIterator(TupleType *tuple) : tuple_type_(tuple) {}
+ 
+ Type *TupleTypeIterator::Next()
+ {
+-    if (iter_ >= tupleType_->Properties().size()) {
++    if (iter_ >= tuple_type_->Properties().size()) {
+         return nullptr;
+     }
+ 
+-    Type *returnType = tupleType_->Properties()[iter_]->TsType();
++    Type *returnType = tuple_type_->Properties()[iter_]->TsType();
+ 
+     iter_++;
+ 
+@@ -36,11 +36,11 @@ Type *TupleTypeIterator::Next()
+ 
+ Type *TupleTypeIterator::Current()
+ {
+-    if (iter_ >= tupleType_->Properties().size()) {
++    if (iter_ >= tuple_type_->Properties().size()) {
+         return nullptr;
+     }
+ 
+-    return tupleType_->Properties()[iter_]->TsType();
++    return tuple_type_->Properties()[iter_]->TsType();
+ }
+ 
+ uint32_t TupleTypeIterator::Iter() const
+@@ -51,10 +51,10 @@ uint32_t TupleTypeIterator::Iter() const
+ TupleType::TupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+                      uint32_t minLength, uint32_t fixedLength, bool readonly)
+     : ObjectType(ObjectType::ObjectTypeKind::TUPLE, desc),
+-      elementFlags_(std::move(elementFlags)),
+-      combinedFlags_(combinedFlags),
+-      minLength_(minLength),
+-      fixedLength_(fixedLength),
++      element_flags_(std::move(elementFlags)),
++      combined_flags_(combinedFlags),
++      min_length_(minLength),
++      fixed_length_(fixedLength),
+       readonly_(readonly)
+ {
+     if (readonly_) {
+@@ -69,11 +69,11 @@ TupleType::TupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags
+ TupleType::TupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
+                      uint32_t minLength, uint32_t fixedLength, bool readonly, NamedTupleMemberPool &&namedMembers)
+     : ObjectType(ObjectType::ObjectTypeKind::TUPLE, desc),
+-      elementFlags_(std::move(elementFlags)),
+-      combinedFlags_(combinedFlags),
+-      minLength_(minLength),
+-      fixedLength_(fixedLength),
+-      namedMembers_(std::move(namedMembers)),
++      element_flags_(std::move(elementFlags)),
++      combined_flags_(combinedFlags),
++      min_length_(minLength),
++      fixed_length_(fixedLength),
++      named_members_(std::move(namedMembers)),
+       readonly_(readonly)
+ {
+     if (readonly_) {
+@@ -94,23 +94,23 @@ TupleType::~TupleType()
+ 
+ ElementFlags TupleType::CombinedFlags() const
+ {
+-    return combinedFlags_;
++    return combined_flags_;
+ }
+ 
+ uint32_t TupleType::MinLength() const
+ {
+-    return minLength_;
++    return min_length_;
+ }
+ 
+ uint32_t TupleType::FixedLength() const
+ {
+-    return fixedLength_;
++    return fixed_length_;
+ }
+ 
+ ElementFlags TupleType::GetElementFlag(const util::StringView &index) const
+ {
+-    auto res = elementFlags_.find(index);
+-    if (res != elementFlags_.end()) {
++    auto res = element_flags_.find(index);
++    if (res != element_flags_.end()) {
+         return res->second;
+     }
+     return ElementFlags::NO_OPTS;
+@@ -118,7 +118,7 @@ ElementFlags TupleType::GetElementFlag(const util::StringView &index) const
+ 
+ bool TupleType::HasCombinedFlag(ElementFlags combinedFlag) const
+ {
+-    return (combinedFlags_ & combinedFlag) != 0;
++    return (combined_flags_ & combinedFlag) != 0;
+ }
+ 
+ bool TupleType::IsReadOnly() const
+@@ -138,12 +138,12 @@ const TupleTypeIterator *TupleType::Iterator() const
+ 
+ const NamedTupleMemberPool &TupleType::NamedMembers() const
+ {
+-    return namedMembers_;
++    return named_members_;
+ }
+ 
+ const util::StringView &TupleType::FindNamedMemberName(binder::LocalVariable *member) const
+ {
+-    auto res = namedMembers_.find(member);
++    auto res = named_members_.find(member);
+     return res->second;
+ }
+ 
+@@ -154,19 +154,19 @@ void TupleType::ToString(std::stringstream &ss) const
+     }
+     ss << "[";
+ 
+-    if (namedMembers_.empty()) {
+-        for (auto it = desc_->properties.begin(); it != desc_->properties.end(); it++) {
++    if (named_members_.empty()) {
++        for (auto it = desc_->properties_.begin(); it != desc_->properties_.end(); it++) {
+             (*it)->TsType()->ToString(ss);
+             if ((*it)->HasFlag(binder::VariableFlags::OPTIONAL)) {
+                 ss << "?";
+             }
+ 
+-            if (std::next(it) != desc_->properties.end()) {
++            if (std::next(it) != desc_->properties_.end()) {
+                 ss << ", ";
+             }
+         }
+     } else {
+-        for (auto it = desc_->properties.begin(); it != desc_->properties.end(); it++) {
++        for (auto it = desc_->properties_.begin(); it != desc_->properties_.end(); it++) {
+             const util::StringView &memberName = FindNamedMemberName(*it);
+             ss << memberName;
+ 
+@@ -176,7 +176,7 @@ void TupleType::ToString(std::stringstream &ss) const
+ 
+             ss << ": ";
+             (*it)->TsType()->ToString(ss);
+-            if (std::next(it) != desc_->properties.end()) {
++            if (std::next(it) != desc_->properties_.end()) {
+                 ss << ", ";
+             }
+         }
+@@ -189,10 +189,10 @@ void TupleType::Identical(TypeRelation *relation, const Type *other) const
+ {
+     if (other->IsObjectType() && other->AsObjectType()->IsTupleType()) {
+         const TupleType *otherTuple = other->AsObjectType()->AsTupleType();
+-        if (kind_ == otherTuple->Kind() && desc_->properties.size() == otherTuple->Properties().size()) {
++        if (kind_ == otherTuple->Kind() && desc_->properties_.size() == otherTuple->Properties().size()) {
+             const auto &otherProperties = otherTuple->Properties();
+-            for (size_t i = 0; i < desc_->properties.size(); i++) {
+-                binder::LocalVariable *targetProp = desc_->properties[i];
++            for (size_t i = 0; i < desc_->properties_.size(); i++) {
++                binder::LocalVariable *targetProp = desc_->properties_[i];
+                 binder::LocalVariable *sourceProp = otherProperties[i];
+ 
+                 if (targetProp->Flags() != sourceProp->Flags()) {
+@@ -227,8 +227,8 @@ void TupleType::AssignmentTarget(TypeRelation *relation, const Type *source) con
+     relation->Result(true);
+ 
+     const auto &sourceProperties = sourceTuple->Properties();
+-    for (size_t i = 0; i < desc_->properties.size(); i++) {
+-        auto *targetProp = desc_->properties[i];
++    for (size_t i = 0; i < desc_->properties_.size(); i++) {
++        auto *targetProp = desc_->properties_[i];
+ 
+         if (i < sourceProperties.size()) {
+             if (!targetProp->HasFlag(binder::VariableFlags::OPTIONAL) &&
+@@ -259,7 +259,7 @@ void TupleType::AssignmentTarget(TypeRelation *relation, const Type *source) con
+ 
+ TypeFacts TupleType::GetTypeFacts() const
+ {
+-    if (desc_->properties.empty()) {
++    if (desc_->properties_.empty()) {
+         return TypeFacts::EMPTY_OBJECT_FACTS;
+     }
+ 
+@@ -272,11 +272,11 @@ Type *TupleType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation,
+ 
+     desc_->Copy(allocator, copiedDesc, relation, globalTypes);
+ 
+-    NamedTupleMemberPool copiedNamedMemberPool = namedMembers_;
+-    TupleElementFlagPool copiedElementFlagPool = elementFlags_;
++    NamedTupleMemberPool copiedNamedMemberPool = named_members_;
++    TupleElementFlagPool copiedElementFlagPool = element_flags_;
+ 
+-    return allocator->New<TupleType>(copiedDesc, std::move(copiedElementFlagPool), combinedFlags_, minLength_,
+-                                     fixedLength_, readonly_, std::move(copiedNamedMemberPool));
++    return allocator->New<TupleType>(copiedDesc, std::move(copiedElementFlagPool), combined_flags_, min_length_,
++                                     fixed_length_, readonly_, std::move(copiedNamedMemberPool));
+ }
+ 
+ }  // namespace panda::es2panda::checker
+diff --git a/typescript/types/tupleType.h b/typescript/types/tupleType.h
+index e64a700..15dd8c7 100644
+--- a/typescript/types/tupleType.h
++++ b/typescript/types/tupleType.h
+@@ -35,7 +35,7 @@ public:
+     uint32_t Iter() const;
+ 
+ private:
+-    TupleType *tupleType_;
++    TupleType *tuple_type_;
+     uint32_t iter_ {0};
+ };
+ 
+@@ -72,11 +72,11 @@ public:
+     Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
+ 
+ private:
+-    TupleElementFlagPool elementFlags_ {};
+-    ElementFlags combinedFlags_ {};
+-    uint32_t minLength_ {};
+-    uint32_t fixedLength_ {};
+-    NamedTupleMemberPool namedMembers_ {};
++    TupleElementFlagPool element_flags_ {};
++    ElementFlags combined_flags_ {};
++    uint32_t min_length_ {};
++    uint32_t fixed_length_ {};
++    NamedTupleMemberPool named_members_ {};
+     bool readonly_ {};
+     TupleTypeIterator *iterator_ {nullptr};
+ };
+diff --git a/typescript/types/type.cpp b/typescript/types/type.cpp
+index 38c732a..513d3b9 100644
+--- a/typescript/types/type.cpp
++++ b/typescript/types/type.cpp
+@@ -21,7 +21,7 @@
+ 
+ namespace panda::es2panda::checker {
+ 
+-Type::Type(TypeFlag flag) : typeFlags_(flag)
++Type::Type(TypeFlag flag) : type_flags_(flag)
+ {
+     static uint64_t typeId = 0;
+     id_ = ++typeId;
+@@ -29,22 +29,22 @@ Type::Type(TypeFlag flag) : typeFlags_(flag)
+ 
+ TypeFlag Type::TypeFlags() const
+ {
+-    return typeFlags_;
++    return type_flags_;
+ }
+ 
+ bool Type::HasTypeFlag(TypeFlag typeFlag) const
+ {
+-    return (typeFlags_ & typeFlag) != 0;
++    return (type_flags_ & typeFlag) != 0;
+ }
+ 
+ void Type::AddTypeFlag(TypeFlag typeFlag)
+ {
+-    typeFlags_ |= typeFlag;
++    type_flags_ |= typeFlag;
+ }
+ 
+ void Type::RemoveTypeFlag(TypeFlag typeFlag)
+ {
+-    typeFlags_ &= ~typeFlag;
++    type_flags_ &= ~typeFlag;
+ }
+ 
+ uint64_t Type::Id() const
+@@ -74,7 +74,7 @@ const binder::Variable *Type::Variable() const
+ 
+ void Type::Identical(TypeRelation *relation, const Type *other) const
+ {
+-    relation->Result(typeFlags_ == other->TypeFlags());
++    relation->Result(type_flags_ == other->TypeFlags());
+ }
+ 
+ bool Type::AssignmentSource([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *target) const
+diff --git a/typescript/types/type.h b/typescript/types/type.h
+index 7c5f311..ee656c1 100644
+--- a/typescript/types/type.h
++++ b/typescript/types/type.h
+@@ -88,7 +88,7 @@ public:
+     virtual Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) = 0;
+ 
+ protected:
+-    TypeFlag typeFlags_;
++    TypeFlag type_flags_;
+     binder::Variable *variable_ {nullptr};  // Variable associated with the type if any
+     uint64_t id_;
+ };
+diff --git a/typescript/types/typeRelation.cpp b/typescript/types/typeRelation.cpp
+index 7bee130..a9540f9 100644
+--- a/typescript/types/typeRelation.cpp
++++ b/typescript/types/typeRelation.cpp
+@@ -46,16 +46,16 @@ RelationResult TypeRelation::CacheLookup(const Type *source, const Type *target,
+     }
+ 
+     RelationKey relationKey {source->Id(), target->Id()};
+-    auto res = holder.cached.find(relationKey);
+-    if (res == holder.cached.end()) {
++    auto res = holder.cached_.find(relationKey);
++    if (res == holder.cached_.end()) {
+         return RelationResult::CACHE_MISS;
+     }
+ 
+-    if (res->second.type >= type && res->second.result == RelationResult::TRUE) {
++    if (res->second.type_ >= type && res->second.result_ == RelationResult::TRUE) {
+         return RelationResult::TRUE;
+     }
+ 
+-    if (res->second.type <= type && res->second.result == RelationResult::FALSE) {
++    if (res->second.type_ <= type && res->second.result_ == RelationResult::FALSE) {
+         return RelationResult::FALSE;
+     }
+ 
+@@ -73,7 +73,7 @@ bool TypeRelation::IsIdenticalTo(const Type *source, const Type *target)
+     if (result_ == RelationResult::CACHE_MISS) {
+         result_ = RelationResult::FALSE;
+         target->Identical(this, source);
+-        checker_->IdenticalResults().cached.insert({{source->Id(), target->Id()}, {result_, RelationType::IDENTICAL}});
++        checker_->IdenticalResults().cached_.insert({{source->Id(), target->Id()}, {result_, RelationType::IDENTICAL}});
+     }
+ 
+     return result_ == RelationResult::TRUE;
+@@ -119,7 +119,7 @@ bool TypeRelation::IsAssignableTo(const Type *source, const Type *target)
+             target->AssignmentTarget(this, source);
+         }
+ 
+-        checker_->AssignableResults().cached.insert(
++        checker_->AssignableResults().cached_.insert(
+             {{source->Id(), target->Id()}, {result_, RelationType::ASSIGNABLE}});
+     }
+ 
+@@ -137,7 +137,7 @@ bool TypeRelation::IsComparableTo(const Type *source, const Type *target)
+ 
+         result_ = RelationResult::FALSE;
+         target->Compare(this, source);
+-        checker_->ComparableResults().cached.insert(
++        checker_->ComparableResults().cached_.insert(
+             {{source->Id(), target->Id()}, {result_, RelationType::COMPARABLE}});
+     }
+ 
+diff --git a/typescript/types/typeRelation.h b/typescript/types/typeRelation.h
+index 9591841..1269ffd 100644
+--- a/typescript/types/typeRelation.h
++++ b/typescript/types/typeRelation.h
+@@ -37,15 +37,15 @@ enum class RelationType { COMPARABLE, ASSIGNABLE, IDENTICAL };
+ 
+ class RelationKey {
+ public:
+-    uint64_t sourceId;
+-    uint64_t targetId;
++    uint64_t source_id_;
++    uint64_t target_id_;
+ };
+ 
+ class RelationKeyHasher {
+ public:
+     size_t operator()(const RelationKey &key) const noexcept
+     {
+-        return static_cast<size_t>(key.sourceId ^ key.targetId);
++        return static_cast<size_t>(key.source_id_ ^ key.target_id_);
+     }
+ };
+ 
+@@ -53,22 +53,22 @@ class RelationKeyComparator {
+ public:
+     bool operator()(const RelationKey &lhs, const RelationKey &rhs) const
+     {
+-        return lhs.sourceId == rhs.sourceId && lhs.targetId == rhs.targetId;
++        return lhs.source_id_ == rhs.source_id_ && lhs.target_id_ == rhs.target_id_;
+     }
+ };
+ 
+ class RealtionEntry {
+ public:
+-    RelationResult result;
+-    RelationType type;
++    RelationResult result_;
++    RelationType type_;
+ };
+ 
+ using RelationMap = std::unordered_map<RelationKey, RealtionEntry, RelationKeyHasher, RelationKeyComparator>;
+ 
+ class RelationHolder {
+ public:
+-    RelationMap cached;
+-    RelationType type {};
++    RelationMap cached_;
++    RelationType type_ {};
+ };
+ 
+ class AsSrc {
+diff --git a/typescript/types/unionType.cpp b/typescript/types/unionType.cpp
+index 54211b5..106b70e 100644
+--- a/typescript/types/unionType.cpp
++++ b/typescript/types/unionType.cpp
+@@ -21,9 +21,9 @@
+ namespace panda::es2panda::checker {
+ 
+ UnionType::UnionType(std::vector<Type *> &&constituentTypes)
+-    : Type(TypeFlag::UNION), constituentTypes_(std::move(constituentTypes))
++    : Type(TypeFlag::UNION), constituent_types_(std::move(constituentTypes))
+ {
+-    for (auto *it : constituentTypes_) {
++    for (auto *it : constituent_types_) {
+         AddConstituentFlag(it->TypeFlags());
+     }
+ }
+@@ -31,19 +31,19 @@ UnionType::UnionType(std::vector<Type *> &&constituentTypes)
+ UnionType::UnionType(std::initializer_list<Type *> types) : Type(TypeFlag::UNION)
+ {
+     for (auto *it : types) {
+-        constituentTypes_.push_back(it);
++        constituent_types_.push_back(it);
+         AddConstituentFlag(it->TypeFlags());
+     }
+ }
+ 
+ const std::vector<Type *> &UnionType::ConstituentTypes() const
+ {
+-    return constituentTypes_;
++    return constituent_types_;
+ }
+ 
+ std::vector<Type *> &UnionType::ConstituentTypes()
+ {
+-    return constituentTypes_;
++    return constituent_types_;
+ }
+ 
+ void UnionType::AddConstituentType(Type *type, TypeRelation *relation)
+@@ -55,36 +55,36 @@ void UnionType::AddConstituentType(Type *type, TypeRelation *relation)
+         return;
+     }
+ 
+-    for (auto *it : constituentTypes_) {
++    for (auto *it : constituent_types_) {
+         if (relation->IsIdenticalTo(it, type)) {
+             return;
+         }
+     }
+ 
+     AddConstituentFlag(type->TypeFlags());
+-    constituentTypes_.push_back(type);
++    constituent_types_.push_back(type);
+ }
+ 
+ void UnionType::AddConstituentFlag(TypeFlag flag)
+ {
+-    constituentFlags_ |= flag;
++    constituent_flags_ |= flag;
+ }
+ 
+ void UnionType::RemoveConstituentFlag(TypeFlag flag)
+ {
+-    constituentFlags_ &= ~flag;
++    constituent_flags_ &= ~flag;
+ }
+ 
+ bool UnionType::HasConstituentFlag(TypeFlag flag) const
+ {
+-    return (constituentFlags_ & flag) != 0;
++    return (constituent_flags_ & flag) != 0;
+ }
+ 
+ void UnionType::ToString(std::stringstream &ss) const
+ {
+-    for (auto it = constituentTypes_.begin(); it != constituentTypes_.end(); it++) {
++    for (auto it = constituent_types_.begin(); it != constituent_types_.end(); it++) {
+         (*it)->ToString(ss);
+-        if (std::next(it) != constituentTypes_.end()) {
++        if (std::next(it) != constituent_types_.end()) {
+             ss << " | ";
+         }
+     }
+@@ -92,13 +92,13 @@ void UnionType::ToString(std::stringstream &ss) const
+ 
+ bool UnionType::EachTypeRelatedToSomeType(TypeRelation *relation, const UnionType *source, const UnionType *target)
+ {
+-    return std::all_of(source->constituentTypes_.begin(), source->constituentTypes_.end(),
++    return std::all_of(source->constituent_types_.begin(), source->constituent_types_.end(),
+                        [relation, target](const auto *s) { return TypeRelatedToSomeType(relation, s, target); });
+ }
+ 
+ bool UnionType::TypeRelatedToSomeType(TypeRelation *relation, const Type *source, const UnionType *target)
+ {
+-    return std::any_of(target->constituentTypes_.begin(), target->constituentTypes_.end(),
++    return std::any_of(target->constituent_types_.begin(), target->constituent_types_.end(),
+                        [relation, source](const auto *t) { return relation->IsIdenticalTo(source, t); });
+ }
+ 
+@@ -117,7 +117,7 @@ void UnionType::Identical(TypeRelation *relation, const Type *other) const
+ 
+ bool UnionType::AssignmentSource(TypeRelation *relation, const Type *target) const
+ {
+-    for (auto *it : constituentTypes_) {
++    for (auto *it : constituent_types_) {
+         if (!relation->IsAssignableTo(it, target)) {
+             return false;
+         }
+@@ -129,7 +129,7 @@ bool UnionType::AssignmentSource(TypeRelation *relation, const Type *target) con
+ 
+ void UnionType::AssignmentTarget(TypeRelation *relation, const Type *source) const
+ {
+-    for (auto *it : constituentTypes_) {
++    for (auto *it : constituent_types_) {
+         if (relation->IsAssignableTo(source, it)) {
+             return;
+         }
+@@ -140,7 +140,7 @@ TypeFacts UnionType::GetTypeFacts() const
+ {
+     TypeFacts facts = TypeFacts::NONE;
+ 
+-    for (auto *it : constituentTypes_) {
++    for (auto *it : constituent_types_) {
+         facts |= it->GetTypeFacts();
+     }
+ 
+@@ -231,9 +231,9 @@ void UnionType::RemoveRedundantLiteralTypesFromUnion(UnionType *type)
+ 
+ Type *UnionType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
+ {
+-    std::vector<Type *> copiedConstituents(constituentTypes_.size());
++    std::vector<Type *> copiedConstituents(constituent_types_.size());
+ 
+-    for (auto *it : constituentTypes_) {
++    for (auto *it : constituent_types_) {
+         copiedConstituents.push_back(it->Instantiate(allocator, relation, globalTypes));
+     }
+ 
+diff --git a/typescript/types/unionType.h b/typescript/types/unionType.h
+index 64aa726..e61c94c 100644
+--- a/typescript/types/unionType.h
++++ b/typescript/types/unionType.h
+@@ -49,8 +49,8 @@ private:
+     static bool EachTypeRelatedToSomeType(TypeRelation *relation, const UnionType *source, const UnionType *target);
+     static bool TypeRelatedToSomeType(TypeRelation *relation, const Type *source, const UnionType *target);
+ 
+-    std::vector<Type *> constituentTypes_;
+-    TypeFlag constituentFlags_ {TypeFlag::NONE};
++    std::vector<Type *> constituent_types_;
++    TypeFlag constituent_flags_ {TypeFlag::NONE};
+ };
+ 
+ }  // namespace panda::es2panda::checker
+diff --git a/util/bitset.cpp b/util/bitset.cpp
+index fca9a34..b3dde41 100644
+--- a/util/bitset.cpp
++++ b/util/bitset.cpp
+@@ -36,7 +36,7 @@ BitSet::~BitSet()
+ 
+ size_t BitSet::DataSize() const noexcept
+ {
+-    return (size_ >> shiftOffset) + 1;
++    return (size_ >> SHIFT_OFFSET) + 1;
+ }
+ 
+ void BitSet::Clear(bool value) noexcept
+@@ -52,8 +52,8 @@ void BitSet::Set(size_t pos) noexcept
+ void BitSet::Set(size_t pos, bool value) noexcept
+ {
+     ASSERT(pos < size_);
+-    size_t idx = pos >> shiftOffset;
+-    size_t slot = pos & shiftMask;
++    size_t idx = pos >> SHIFT_OFFSET;
++    size_t slot = pos & SHIFT_MASK;
+ 
+     if (value) {
+         data_[idx] |= 1U << slot;
+@@ -65,8 +65,8 @@ void BitSet::Set(size_t pos, bool value) noexcept
+ bool BitSet::Test(size_t pos) const noexcept
+ {
+     ASSERT(pos < size_);
+-    size_t idx = pos >> shiftOffset;
+-    size_t slot = pos & shiftMask;
++    size_t idx = pos >> SHIFT_OFFSET;
++    size_t slot = pos & SHIFT_MASK;
+ 
+     return (data_[idx] & (1U << slot)) != 0;
+ }
+diff --git a/util/bitset.h b/util/bitset.h
+index ad621e0..20c899d 100644
+--- a/util/bitset.h
++++ b/util/bitset.h
+@@ -36,8 +36,8 @@ public:
+     bool Test(size_t pos) const noexcept;
+ 
+ private:
+-    static const size_t shiftOffset = 3;
+-    static const size_t shiftMask = (1U << shiftOffset) - 1;
++    static const size_t SHIFT_OFFSET = 3;
++    static const size_t SHIFT_MASK = (1U << SHIFT_OFFSET) - 1;
+     size_t DataSize() const noexcept;
+ 
+     uint8_t *data_;
diff --git a/typescript/checker.cpp b/typescript/checker.cpp
index 71be1ad7d6ee73574f6597075110affee7e6ee25..dce46134787fe05d4f4beff347ed963ece67e00c 100644
--- a/typescript/checker.cpp
+++ b/typescript/checker.cpp
@@ -33,19 +33,19 @@ namespace panda::es2panda::checker {
 Checker::Checker(ArenaAllocator *allocator, binder::Binder *binder)
     : allocator_(allocator),
       binder_(binder),
-      rootNode_(binder->TopScope()->Node()->AsBlockStatement()),
+      root_node_(binder->TopScope()->Node()->AsBlockStatement()),
       scope_(binder->TopScope())
 {
-    scopeStack_.push_back(scope_);
-    globalTypes_ = allocator_->New<GlobalTypesHolder>(allocator_);
+    scope_stack_.push_back(scope_);
+    global_types_ = allocator_->New<GlobalTypesHolder>(allocator_);
     relation_ = allocator_->New<TypeRelation>(this);
     status_ = CheckerStatus::NO_OPTS;
 }
 
 void Checker::StartChecker()
 {
-    ASSERT(rootNode_->IsProgram());
-    rootNode_->Check(this);
+    ASSERT(root_node_->IsProgram());
+    root_node_->Check(this);
 }
 
 binder::Scope *Checker::Scope() const
@@ -84,127 +84,127 @@ void Checker::ThrowTypeError(std::string_view message, const lexer::SourcePositi
     lexer::LineIndex index(binder_->Program()->SourceCode());
     lexer::SourceLocation loc = index.GetLocation(pos);
 
-    throw Error {ErrorType::TYPE, message, loc.line, loc.col};
+    throw Error {ErrorType::TYPE, message, loc.line_, loc.col_};
 }
 
 Type *Checker::GlobalNumberType()
 {
-    return globalTypes_->GlobalNumberType();
+    return global_types_->GlobalNumberType();
 }
 
 Type *Checker::GlobalAnyType()
 {
-    return globalTypes_->GlobalAnyType();
+    return global_types_->GlobalAnyType();
 }
 
 Type *Checker::GlobalStringType()
 {
-    return globalTypes_->GlobalStringType();
+    return global_types_->GlobalStringType();
 }
 
 Type *Checker::GlobalBooleanType()
 {
-    return globalTypes_->GlobalBooleanType();
+    return global_types_->GlobalBooleanType();
 }
 
 Type *Checker::GlobalVoidType()
 {
-    return globalTypes_->GlobalVoidType();
+    return global_types_->GlobalVoidType();
 }
 
 Type *Checker::GlobalNullType()
 {
-    return globalTypes_->GlobalNullType();
+    return global_types_->GlobalNullType();
 }
 
 Type *Checker::GlobalUndefinedType()
 {
-    return globalTypes_->GlobalUndefinedType();
+    return global_types_->GlobalUndefinedType();
 }
 
 Type *Checker::GlobalUnknownType()
 {
-    return globalTypes_->GlobalUnknownType();
+    return global_types_->GlobalUnknownType();
 }
 
 Type *Checker::GlobalNeverType()
 {
-    return globalTypes_->GlobalNeverType();
+    return global_types_->GlobalNeverType();
 }
 
 Type *Checker::GlobalNonPrimitiveType()
 {
-    return globalTypes_->GlobalNonPrimitiveType();
+    return global_types_->GlobalNonPrimitiveType();
 }
 
 Type *Checker::GlobalBigintType()
 {
-    return globalTypes_->GlobalBigintType();
+    return global_types_->GlobalBigintType();
 }
 
 Type *Checker::GlobalFalseType()
 {
-    return globalTypes_->GlobalFalseType();
+    return global_types_->GlobalFalseType();
 }
 
 Type *Checker::GlobalTrueType()
 {
-    return globalTypes_->GlobalTrueType();
+    return global_types_->GlobalTrueType();
 }
 
 Type *Checker::GlobalNumberOrBigintType()
 {
-    return globalTypes_->GlobalNumberOrBigintType();
+    return global_types_->GlobalNumberOrBigintType();
 }
 
 Type *Checker::GlobalStringOrNumberType()
 {
-    return globalTypes_->GlobalStringOrNumberType();
+    return global_types_->GlobalStringOrNumberType();
 }
 
 Type *Checker::GlobalZeroType()
 {
-    return globalTypes_->GlobalZeroType();
+    return global_types_->GlobalZeroType();
 }
 
 Type *Checker::GlobalEmptyStringType()
 {
-    return globalTypes_->GlobalEmptyStringType();
+    return global_types_->GlobalEmptyStringType();
 }
 
 Type *Checker::GlobalZeroBigintType()
 {
-    return globalTypes_->GlobalZeroBigintType();
+    return global_types_->GlobalZeroBigintType();
 }
 
 Type *Checker::GlobalPrimitiveType()
 {
-    return globalTypes_->GlobalPrimitiveType();
+    return global_types_->GlobalPrimitiveType();
 }
 
 Type *Checker::GlobalEmptyTupleType()
 {
-    return globalTypes_->GlobalEmptyTupleType();
+    return global_types_->GlobalEmptyTupleType();
 }
 
 Type *Checker::GlobalEmptyObjectType()
 {
-    return globalTypes_->GlobalEmptyObjectType();
+    return global_types_->GlobalEmptyObjectType();
 }
 
 NumberLiteralPool &Checker::NumberLiteralMap()
 {
-    return numberLiteralMap_;
+    return number_literal_map_;
 }
 
 StringLiteralPool &Checker::StringLiteralMap()
 {
-    return stringLiteralMap_;
+    return string_literal_map_;
 }
 
 StringLiteralPool &Checker::BigintLiteralMap()
 {
-    return bigintLiteralMap_;
+    return bigint_literal_map_;
 }
 
 TypeRelation *Checker::Relation()
@@ -214,27 +214,27 @@ TypeRelation *Checker::Relation()
 
 RelationHolder &Checker::IdenticalResults()
 {
-    return identicalResults_;
+    return identical_results_;
 }
 
 RelationHolder &Checker::AssignableResults()
 {
-    return assignableResults_;
+    return assignable_results_;
 }
 
 RelationHolder &Checker::ComparableResults()
 {
-    return comparableResults_;
+    return comparable_results_;
 }
 
 std::unordered_set<const ir::AstNode *> &Checker::TypeStack()
 {
-    return typeStack_;
+    return type_stack_;
 }
 
 std::unordered_map<const ir::AstNode *, Type *> &Checker::NodeCache()
 {
-    return nodeCache_;
+    return node_cache_;
 }
 
 CheckerStatus Checker::Status()
@@ -244,13 +244,13 @@ CheckerStatus Checker::Status()
 
 Type *Checker::CheckTypeCached(const ir::Expression *expr)
 {
-    auto res = nodeCache_.find(expr);
-    if (res != nodeCache_.end()) {
+    auto res = node_cache_.find(expr);
+    if (res != node_cache_.end()) {
         return res->second;
     }
 
     Type *returnType = expr->Check(this);
-    nodeCache_.insert({expr, returnType});
+    node_cache_.insert({expr, returnType});
 
     return returnType;
 }
diff --git a/typescript/checker.h b/typescript/checker.h
index 7063aa6dcd4a8ded76bbf09f0c78dfd4333935a4..51da1bcd94d9b80782a94718c39a7f5a11062f02 100644
--- a/typescript/checker.h
+++ b/typescript/checker.h
@@ -125,12 +125,12 @@ public:
     NO_COPY_SEMANTIC(ObjectLiteralElaborationData);
     NO_MOVE_SEMANTIC(ObjectLiteralElaborationData);
 
-    ObjectDescriptor *desc {};
-    std::vector<Type *> stringIndexTypes {};
-    Type *numberInfosType {};
-    Type *stringInfosType {};
-    std::vector<const ir::SpreadElement *> spreads {};
-    std::unordered_map<uint32_t, ObjectType *> potentialObjectTypes {};
+    ObjectDescriptor *desc_ {};
+    std::vector<Type *> string_index_types_ {};
+    Type *number_infos_type_ {};
+    Type *string_infos_type_ {};
+    std::vector<const ir::SpreadElement *> spreads_ {};
+    std::unordered_map<uint32_t, ObjectType *> potential_object_types_ {};
 };
 
 class ObjectLiteralPropertyInfo {
@@ -140,9 +140,9 @@ public:
     NO_COPY_SEMANTIC(ObjectLiteralPropertyInfo);
     DEFAULT_MOVE_SEMANTIC(ObjectLiteralPropertyInfo);
 
-    util::StringView propName {};
-    Type *propType {};
-    bool handleNextProp {};
+    util::StringView prop_name_ {};
+    Type *prop_type_ {};
+    bool handle_next_prop_ {};
 };
 
 class FunctionParameterInfo {
@@ -152,14 +152,14 @@ public:
     NO_COPY_SEMANTIC(FunctionParameterInfo);
     DEFAULT_MOVE_SEMANTIC(FunctionParameterInfo);
 
-    const ir::Expression *typeAnnotation {};
-    const ir::Expression *initNode {};
-    const ir::Expression *bindingNode {};
-    Type *initType {};
-    Type *restType {};
-    DestructuringType destructuringType {DestructuringType::NO_DESTRUCTURING};
-    bool optionalParam {};
-    util::StringView paramName {};
+    const ir::Expression *type_annotation_ {};
+    const ir::Expression *init_node_ {};
+    const ir::Expression *binding_node_ {};
+    Type *init_type_ {};
+    Type *rest_type_ {};
+    DestructuringType destructuring_type_ {DestructuringType::NO_DESTRUCTURING};
+    bool optional_param_ {};
+    util::StringView param_name_ {};
 };
 
 enum class CheckerStatus {
@@ -473,37 +473,37 @@ public:
 private:
     ArenaAllocator *allocator_;
     binder::Binder *binder_;
-    const ir::BlockStatement *rootNode_;
+    const ir::BlockStatement *root_node_;
     binder::Scope *scope_;
-    GlobalTypesHolder *globalTypes_;
+    GlobalTypesHolder *global_types_;
 
-    NumberLiteralPool numberLiteralMap_;
-    StringLiteralPool stringLiteralMap_;
-    StringLiteralPool bigintLiteralMap_;
+    NumberLiteralPool number_literal_map_;
+    StringLiteralPool string_literal_map_;
+    StringLiteralPool bigint_literal_map_;
 
     TypeRelation *relation_;
 
-    RelationHolder identicalResults_;
-    RelationHolder assignableResults_;
-    RelationHolder comparableResults_;
+    RelationHolder identical_results_;
+    RelationHolder assignable_results_;
+    RelationHolder comparable_results_;
 
-    std::unordered_set<const ir::AstNode *> typeStack_;
-    std::unordered_map<const ir::AstNode *, Type *> nodeCache_;
-    std::vector<binder::Scope *> scopeStack_;
+    std::unordered_set<const ir::AstNode *> type_stack_;
+    std::unordered_map<const ir::AstNode *, Type *> node_cache_;
+    std::vector<binder::Scope *> scope_stack_;
 
     CheckerStatus status_;
 };
 
 class ScopeContext {
 public:
-    explicit ScopeContext(Checker *checker, binder::Scope *newScope) : checker_(checker), prevScope_(checker_->scope_)
+    explicit ScopeContext(Checker *checker, binder::Scope *newScope) : checker_(checker), prev_scope_(checker_->scope_)
     {
         checker_->scope_ = newScope;
     }
 
     ~ScopeContext()
     {
-        checker_->scope_ = prevScope_;
+        checker_->scope_ = prev_scope_;
     }
 
     NO_COPY_SEMANTIC(ScopeContext);
@@ -511,7 +511,7 @@ public:
 
 private:
     Checker *checker_;
-    binder::Scope *prevScope_;
+    binder::Scope *prev_scope_;
 };
 
 }  // namespace panda::es2panda::checker
diff --git a/typescript/core/destructuring.cpp b/typescript/core/destructuring.cpp
index 0e875a46cce57aa32c46f4b545c4a60935fdd6e0..1cbe84c3815c435e1019db7f6a5c49db47d7c5fd 100644
--- a/typescript/core/destructuring.cpp
+++ b/typescript/core/destructuring.cpp
@@ -95,27 +95,27 @@ void Checker::HandleIdentifierDeclarationWithContext(const ir::Identifier *ident
     binder::ScopeFindResult result = scope_->Find(identName);
 
     if (inAssignment) {
-        if (!result.variable) {
+        if (!result.variable_) {
             ThrowTypeError({"Cannot find name '", identName, "'."}, identNode->Start());
         }
 
         Type *varType = GetVariableType(identName, inferedType, nullptr, nullptr, destructuringType, identNode->Start(),
                                         annotationTypeUsed, true);
 
-        if (!IsTypeAssignableTo(varType, result.variable->TsType())) {
-            ThrowAssignmentError(varType, result.variable->TsType(), identNode->Start());
+        if (!IsTypeAssignableTo(varType, result.variable_->TsType())) {
+            ThrowAssignmentError(varType, result.variable_->TsType(), identNode->Start());
         }
 
         return;
     }
 
-    ASSERT(result.variable);
+    ASSERT(result.variable_);
 
-    Type *varType = GetVariableType(identNode->Name(), inferedType, nullptr, result.variable, destructuringType,
+    Type *varType = GetVariableType(identNode->Name(), inferedType, nullptr, result.variable_, destructuringType,
                                     identNode->Start(), annotationTypeUsed);
 
-    varType->SetVariable(result.variable);
-    result.variable->SetTsType(varType);
+    varType->SetVariable(result.variable_);
+    result.variable_->SetTsType(varType);
 }
 
 void Checker::HandlePropertyDeclarationWithContext(const ir::Property *prop, Type *inferedType,
@@ -170,7 +170,7 @@ void Checker::HandlePropertyDeclarationWithContext(const ir::Property *prop, Typ
 
     if (fetchVar) {
         binder::ScopeFindResult result = scope_->Find(searchVarName);
-        resultVar = result.variable;
+        resultVar = result.variable_;
     }
     if (fetchVar && inAssignment && !resultVar) {
         ThrowTypeError({"No value exists in scope for the shorthand property '", searchVarName,
@@ -208,31 +208,31 @@ void Checker::HandleAssignmentPatternWithContext(const ir::AssignmentExpression
         binder::ScopeFindResult result = scope_->Find(identNode->Name());
 
         if (inAssignment) {
-            if (!result.variable) {
+            if (!result.variable_) {
                 ThrowTypeError({"Cannot find name '", identNode->Name(), "'."}, identNode->Start());
             }
 
-            if (!IsTypeAssignableTo(initType, result.variable->TsType())) {
-                ThrowAssignmentError(initType, result.variable->TsType(), identNode->Start());
+            if (!IsTypeAssignableTo(initType, result.variable_->TsType())) {
+                ThrowAssignmentError(initType, result.variable_->TsType(), identNode->Start());
             }
 
             Type *varType = GetVariableType(identNode->Name(), inferedType, GetBaseTypeOfLiteralType(initType), nullptr,
                                             destructuringType, identNode->Start(), annotationTypeUsed, true);
 
-            if (!IsTypeAssignableTo(varType, result.variable->TsType())) {
-                ThrowAssignmentError(varType, result.variable->TsType(), identNode->Start());
+            if (!IsTypeAssignableTo(varType, result.variable_->TsType())) {
+                ThrowAssignmentError(varType, result.variable_->TsType(), identNode->Start());
             }
 
             return;
         }
 
-        ASSERT(result.variable);
+        ASSERT(result.variable_);
 
         Type *varType = GetVariableType(identNode->Name(), inferedType, GetBaseTypeOfLiteralType(initType),
-                                        result.variable, destructuringType, identNode->Start(), annotationTypeUsed);
+                                        result.variable_, destructuringType, identNode->Start(), annotationTypeUsed);
 
-        varType->SetVariable(result.variable);
-        result.variable->SetTsType(varType);
+        varType->SetVariable(result.variable_);
+        result.variable_->SetTsType(varType);
 
         return;
     }
@@ -313,13 +313,13 @@ void Checker::HandleRestElementWithContext(const ir::SpreadElement *restElement,
 
     if (restElement->Argument()->IsIdentifier()) {
         binder::ScopeFindResult result = scope_->Find(restElement->Argument()->AsIdentifier()->Name());
-        if (inAssignment && !result.variable) {
+        if (inAssignment && !result.variable_) {
             ThrowTypeError({"Cannot find name '", restElement->Argument()->AsIdentifier()->Name(), "'."},
                            restElement->Argument()->Start());
         }
 
-        ASSERT(result.variable);
-        restVar = result.variable;
+        ASSERT(result.variable_);
+        restVar = result.variable_;
     }
 
     Type *restType =
@@ -675,7 +675,7 @@ Type *Checker::CreateObjectTypeForRest(ObjectType *objType)
             memberVar->SetTsType(it->TsType());
             it->RemoveFlag(binder::VariableFlags::INFERED_IN_PATTERN);
             memberVar->AddFlag(it->Flags());
-            desc->properties.push_back(memberVar);
+            desc->properties_.push_back(memberVar);
         }
     }
 
@@ -699,7 +699,7 @@ Type *Checker::CreateTupleTypeForRest(TupleTypeIterator *iterator)
         auto *memberVar = binder::Scope::CreateVar(allocator_, memberIndex, binder::VariableFlags::PROPERTY, nullptr);
         memberVar->SetTsType(elementType);
         elementFlags.insert({memberIndex, memberFlag});
-        desc->properties.push_back(memberVar);
+        desc->properties_.push_back(memberVar);
 
         index++;
         iter = iterator->Next();
@@ -795,7 +795,7 @@ Type *Checker::CreateInitializerTypeForArrayPattern(const TupleType *patternType
 
     ObjectType *initTupleType = initNode->Check(this)->AsObjectType()->AsTupleType();
 
-    nodeCache_.insert({initNode, initTupleType});
+    node_cache_.insert({initNode, initTupleType});
 
     for (size_t it = 0; it < initNode->Elements().size(); it++) {
         if (patternType->FixedLength() < it) {
diff --git a/typescript/core/function.cpp b/typescript/core/function.cpp
index 09006bd449defc4704f93e031d1a5e6a1f58e62a..cc9d0fd485af8292fc333448f1b9f606c4e48712 100644
--- a/typescript/core/function.cpp
+++ b/typescript/core/function.cpp
@@ -150,68 +150,68 @@ Type *Checker::CreateTypeForPatternParameter(const ir::Expression *patternNode,
 void Checker::CheckFunctionParameterDeclaration(const ArenaVector<ir::Expression *> &params,
                                                 SignatureInfo *signatureInfo)
 {
-    signatureInfo->restVar = nullptr;
-    signatureInfo->minArgCount = 0;
+    signatureInfo->rest_var_ = nullptr;
+    signatureInfo->min_arg_count_ = 0;
 
     for (auto *it : params) {
         FunctionParameterInfo paramInfo = GetFunctionParameterInfo(it);
 
         VariableBindingContext context = VariableBindingContext::REGULAR;
 
-        Type *annotationType = paramInfo.typeAnnotation ? CheckTypeCached(paramInfo.typeAnnotation) : nullptr;
+        Type *annotationType = paramInfo.type_annotation_ ? CheckTypeCached(paramInfo.type_annotation_) : nullptr;
 
         TypeOrNode elaborateSource;
 
-        if (paramInfo.initNode && annotationType) {
-            elaborateSource = paramInfo.initNode;
+        if (paramInfo.init_node_ && annotationType) {
+            elaborateSource = paramInfo.init_node_;
             if (!ElaborateElementwise(elaborateSource, annotationType, it->Start()) &&
-                !IsTypeAssignableTo(paramInfo.initType, annotationType)) {
+                !IsTypeAssignableTo(paramInfo.init_type_, annotationType)) {
                 ThrowTypeError(
-                    {"Type '", AsSrc(paramInfo.initType), "' is not assignable to type '", annotationType, "'"},
+                    {"Type '", AsSrc(paramInfo.init_type_), "' is not assignable to type '", annotationType, "'"},
                     it->Start());
             }
         }
 
-        Type *patternType = paramInfo.destructuringType != DestructuringType::NO_DESTRUCTURING
-                                ? paramInfo.bindingNode->Check(this)
+        Type *patternType = paramInfo.destructuring_type_ != DestructuringType::NO_DESTRUCTURING
+                                ? paramInfo.binding_node_->Check(this)
                                 : nullptr;
 
         if (patternType) {
             if (annotationType) {
                 elaborateSource = patternType;
                 ElaborateElementwise(elaborateSource, annotationType, it->Start());
-            } else if (paramInfo.initNode) {
-                paramInfo.initType = CreateInitializerTypeForPattern(patternType, paramInfo.initNode);
+            } else if (paramInfo.init_node_) {
+                paramInfo.init_type_ = CreateInitializerTypeForPattern(patternType, paramInfo.init_node_);
             }
         }
 
         Type *paramType = GetParamTypeFromParamInfo(paramInfo, annotationType, patternType);
 
-        HandleVariableDeclarationWithContext(paramInfo.bindingNode, paramType, context, paramInfo.destructuringType,
-                                             paramInfo.typeAnnotation);
+        HandleVariableDeclarationWithContext(paramInfo.binding_node_, paramType, context, paramInfo.destructuring_type_,
+                                             paramInfo.type_annotation_);
 
         // TODO(aszilagyi): get the variable from the function scope
         binder::LocalVariable *paramVar = nullptr;
 
-        paramType = paramInfo.destructuringType != DestructuringType::NO_DESTRUCTURING
-                        ? CreateTypeForPatternParameter(paramInfo.bindingNode, paramInfo.initNode)
+        paramType = paramInfo.destructuring_type_ != DestructuringType::NO_DESTRUCTURING
+                        ? CreateTypeForPatternParameter(paramInfo.binding_node_, paramInfo.init_node_)
                         : paramType;
 
         paramType->SetVariable(paramVar);
         paramVar->SetTsType(paramType);
 
-        if (paramInfo.restType) {
-            signatureInfo->restVar = paramVar;
+        if (paramInfo.rest_type_) {
+            signatureInfo->rest_var_ = paramVar;
             continue;
         }
 
-        if (!paramInfo.optionalParam) {
-            signatureInfo->minArgCount++;
+        if (!paramInfo.optional_param_) {
+            signatureInfo->min_arg_count_++;
         } else {
             paramVar->AddFlag(binder::VariableFlags::OPTIONAL);
         }
 
-        signatureInfo->funcParams.push_back(paramVar);
+        signatureInfo->func_params_.push_back(paramVar);
     }
 }
 
@@ -235,12 +235,12 @@ void Checker::InferFunctionDeclarationType(const binder::FunctionDecl *decl, bin
 
             Signature *overloadSignature = allocator_->New<Signature>(signatureInfo, returnType);
 
-            descWithOverload->callSignatures.push_back(overloadSignature);
+            descWithOverload->call_signatures_.push_back(overloadSignature);
 
             continue;
         }
 
-        if (descWithOverload->callSignatures.empty()) {
+        if (descWithOverload->call_signatures_.empty()) {
             ScopeContext scopeCtx(this, func->Scope());
 
             auto *signatureInfo = allocator_->New<checker::SignatureInfo>();
@@ -335,54 +335,54 @@ FunctionParameterInfo Checker::GetFunctionParameterInfo(ir::Expression *expr)
 {
     std::stringstream ss;
     FunctionParameterInfo paramInfo;
-    paramInfo.bindingNode = expr;
+    paramInfo.binding_node_ = expr;
 
     if (expr->IsArrayPattern()) {
-        paramInfo.typeAnnotation = expr->AsArrayPattern()->TypeAnnotation();
-        paramInfo.destructuringType = DestructuringType::ARRAY_DESTRUCTURING;
+        paramInfo.type_annotation_ = expr->AsArrayPattern()->TypeAnnotation();
+        paramInfo.destructuring_type_ = DestructuringType::ARRAY_DESTRUCTURING;
         CreatePatternName(expr, ss);
         util::UString pn(ss.str(), allocator_);
-        paramInfo.paramName = pn.View();
+        paramInfo.param_name_ = pn.View();
         return paramInfo;
     }
 
     if (expr->IsObjectPattern()) {
-        paramInfo.typeAnnotation = expr->AsObjectPattern()->TypeAnnotation();
-        paramInfo.destructuringType = DestructuringType::OBJECT_DESTRUCTURING;
+        paramInfo.type_annotation_ = expr->AsObjectPattern()->TypeAnnotation();
+        paramInfo.destructuring_type_ = DestructuringType::OBJECT_DESTRUCTURING;
         CreatePatternName(expr, ss);
         util::UString pn(ss.str(), allocator_);
-        paramInfo.paramName = pn.View();
+        paramInfo.param_name_ = pn.View();
         return paramInfo;
     }
 
     if (expr->IsAssignmentPattern()) {
         ir::AssignmentExpression *assignmentPattern = expr->AsAssignmentPattern();
-        paramInfo.initNode = assignmentPattern->Right();
-        paramInfo.bindingNode = assignmentPattern->Left();
-        paramInfo.optionalParam = true;
+        paramInfo.init_node_ = assignmentPattern->Right();
+        paramInfo.binding_node_ = assignmentPattern->Left();
+        paramInfo.optional_param_ = true;
 
-        if (paramInfo.bindingNode->IsArrayPattern()) {
-            paramInfo.typeAnnotation = paramInfo.bindingNode->AsArrayPattern()->TypeAnnotation();
+        if (paramInfo.binding_node_->IsArrayPattern()) {
+            paramInfo.type_annotation_ = paramInfo.binding_node_->AsArrayPattern()->TypeAnnotation();
             // TODO(aszilagyi): 1st param true
-            paramInfo.initType = expr->AsAssignmentPattern()->Right()->Check(this);
-            paramInfo.destructuringType = DestructuringType::ARRAY_DESTRUCTURING;
+            paramInfo.init_type_ = expr->AsAssignmentPattern()->Right()->Check(this);
+            paramInfo.destructuring_type_ = DestructuringType::ARRAY_DESTRUCTURING;
             CreatePatternName(expr, ss);
             util::UString pn(ss.str(), allocator_);
-            paramInfo.paramName = pn.View();
+            paramInfo.param_name_ = pn.View();
         } else {
-            if (paramInfo.bindingNode->IsObjectPattern()) {
-                paramInfo.typeAnnotation = paramInfo.bindingNode->AsObjectPattern()->TypeAnnotation();
-                paramInfo.destructuringType = DestructuringType::OBJECT_DESTRUCTURING;
+            if (paramInfo.binding_node_->IsObjectPattern()) {
+                paramInfo.type_annotation_ = paramInfo.binding_node_->AsObjectPattern()->TypeAnnotation();
+                paramInfo.destructuring_type_ = DestructuringType::OBJECT_DESTRUCTURING;
                 CreatePatternName(expr, ss);
                 util::UString pn(ss.str(), allocator_);
-                paramInfo.paramName = pn.View();
+                paramInfo.param_name_ = pn.View();
             } else {
-                ASSERT(paramInfo.bindingNode->IsIdentifier());
-                paramInfo.typeAnnotation = paramInfo.bindingNode->AsIdentifier()->TypeAnnotation();
-                paramInfo.paramName = paramInfo.bindingNode->AsIdentifier()->Name();
+                ASSERT(paramInfo.binding_node_->IsIdentifier());
+                paramInfo.type_annotation_ = paramInfo.binding_node_->AsIdentifier()->TypeAnnotation();
+                paramInfo.param_name_ = paramInfo.binding_node_->AsIdentifier()->Name();
             }
 
-            paramInfo.initType = expr->AsAssignmentPattern()->Right()->Check(this);
+            paramInfo.init_type_ = expr->AsAssignmentPattern()->Right()->Check(this);
         }
 
         return paramInfo;
@@ -390,7 +390,7 @@ FunctionParameterInfo Checker::GetFunctionParameterInfo(ir::Expression *expr)
 
     if (expr->IsRestElement()) {
         ir::SpreadElement *restElement = expr->AsRestElement();
-        paramInfo.restType = GlobalAnyType();
+        paramInfo.rest_type_ = GlobalAnyType();
 
         if (restElement->TypeAnnotation()) {
             Type *restArrayType = restElement->TypeAnnotation()->Check(this);
@@ -399,19 +399,19 @@ FunctionParameterInfo Checker::GetFunctionParameterInfo(ir::Expression *expr)
                 ThrowTypeError("A rest parameter must be of an array type", expr->Start());
             }
 
-            paramInfo.restType = restArrayType->AsArrayType()->ElementType();
+            paramInfo.rest_type_ = restArrayType->AsArrayType()->ElementType();
         }
 
-        paramInfo.paramName = restElement->Argument()->AsIdentifier()->Name();
-        paramInfo.bindingNode = restElement->Argument();
+        paramInfo.param_name_ = restElement->Argument()->AsIdentifier()->Name();
+        paramInfo.binding_node_ = restElement->Argument();
 
         return paramInfo;
     }
 
     ASSERT(expr->IsIdentifier());
-    paramInfo.typeAnnotation = expr->AsIdentifier()->TypeAnnotation();
-    paramInfo.optionalParam = expr->AsIdentifier()->IsOptional();
-    paramInfo.paramName = expr->AsIdentifier()->Name();
+    paramInfo.type_annotation_ = expr->AsIdentifier()->TypeAnnotation();
+    paramInfo.optional_param_ = expr->AsIdentifier()->IsOptional();
+    paramInfo.param_name_ = expr->AsIdentifier()->Name();
 
     return paramInfo;
 }
@@ -419,20 +419,20 @@ FunctionParameterInfo Checker::GetFunctionParameterInfo(ir::Expression *expr)
 Type *Checker::GetParamTypeFromParamInfo(const FunctionParameterInfo &paramInfo, Type *annotationType,
                                          Type *patternType)
 {
-    if (paramInfo.typeAnnotation) {
+    if (paramInfo.type_annotation_) {
         return annotationType;
     }
 
-    if (paramInfo.initType) {
-        return paramInfo.initType;
+    if (paramInfo.init_type_) {
+        return paramInfo.init_type_;
     }
 
     if (patternType) {
         return patternType;
     }
 
-    if (paramInfo.restType) {
-        return paramInfo.restType;
+    if (paramInfo.rest_type_) {
+        return paramInfo.rest_type_;
     }
 
     return GlobalAnyType();
diff --git a/typescript/core/generics.cpp b/typescript/core/generics.cpp
index b3ee8bb7f3e781bedf6d124f3b79050def368c84..446566cb1fa6aeab057dcf84675a3199efc37f57 100644
--- a/typescript/core/generics.cpp
+++ b/typescript/core/generics.cpp
@@ -60,9 +60,9 @@ Type *Checker::InstantiateGenericTypeAlias(binder::Variable *bindingVar, const i
         for (size_t it = 0; it < typeParams->Params().size(); it++) {
             binder::ScopeFindResult res = scope_->Find(decl->Params()[it]->Name()->Name());
 
-            ASSERT(res.variable && res.variable->TsType() && res.variable->TsType()->IsTypeParameter());
+            ASSERT(res.variable_ && res.variable_->TsType() && res.variable_->TsType()->IsTypeParameter());
 
-            TypeParameter *currentTypeParameterType = res.variable->TsType()->AsTypeParameter();
+            TypeParameter *currentTypeParameterType = res.variable_->TsType()->AsTypeParameter();
 
             savedDefaultTypes.emplace_back(currentTypeParameterType, currentTypeParameterType->DefaultType());
 
@@ -70,7 +70,7 @@ Type *Checker::InstantiateGenericTypeAlias(binder::Variable *bindingVar, const i
         }
     }
 
-    Type *newGenericType = bindingVar->TsType()->Instantiate(allocator_, relation_, globalTypes_);
+    Type *newGenericType = bindingVar->TsType()->Instantiate(allocator_, relation_, global_types_);
 
     for (auto it : savedDefaultTypes) {
         it.first->SetDefaultType(it.second);
@@ -123,9 +123,9 @@ Type *Checker::InstantiateGenericInterface(binder::Variable *bindingVar, const b
         for (size_t i = 0; i < currentTypeParams->Params().size(); i++) {
             binder::ScopeFindResult res = scope_->Find(currentTypeParams->Params()[i]->Name()->Name());
 
-            ASSERT(res.variable && res.variable->TsType() && res.variable->TsType()->IsTypeParameter());
+            ASSERT(res.variable_ && res.variable_->TsType() && res.variable_->TsType()->IsTypeParameter());
 
-            TypeParameter *currentTypeParameterType = res.variable->TsType()->AsTypeParameter();
+            TypeParameter *currentTypeParameterType = res.variable_->TsType()->AsTypeParameter();
 
             savedDefaultTypes.emplace_back(currentTypeParameterType, currentTypeParameterType->DefaultType());
 
@@ -134,7 +134,7 @@ Type *Checker::InstantiateGenericInterface(binder::Variable *bindingVar, const b
         }
     }
 
-    Type *newGenericType = bindingVar->TsType()->Instantiate(allocator_, relation_, globalTypes_);
+    Type *newGenericType = bindingVar->TsType()->Instantiate(allocator_, relation_, global_types_);
 
     newGenericType->AsObjectType()->AsInterfaceType()->SetTypeParamTypes(std::move(typeParamInstantiationTypes));
 
@@ -176,30 +176,30 @@ std::vector<binder::Variable *> Checker::CheckTypeParameters(const ir::TSTypePar
         const ir::TSTypeParameter *currentParam = typeParams->Params()[i];
 
         binder::ScopeFindResult res = scope_->Find(currentParam->Name()->Name());
-        ASSERT(res.variable);
+        ASSERT(res.variable_);
 
-        if (!res.variable->TsType()) {
+        if (!res.variable_->TsType()) {
             Type *defaultType = nullptr;
             if (currentParam->DefaultType()) {
                 CheckTypeParametersNotReferenced(currentParam->DefaultType(), typeParams, i + 1);
 
-                if (!typeStack_.insert(currentParam->DefaultType()).second) {
+                if (!type_stack_.insert(currentParam->DefaultType()).second) {
                     ThrowTypeError({"Type parameter '", currentParam->Name()->Name(), "' has a circular default."},
                                    currentParam->DefaultType()->Start());
                 }
 
                 defaultType = currentParam->DefaultType()->Check(this);
 
-                typeStack_.erase(currentParam->DefaultType());
+                type_stack_.erase(currentParam->DefaultType());
             }
 
             // TODO(aszilagyi): handle type parameter constraints
             auto *paramType = allocator_->New<TypeParameter>(nullptr, defaultType);
 
-            res.variable->SetTsType(paramType);
+            res.variable_->SetTsType(paramType);
         }
 
-        params.push_back(res.variable);
+        params.push_back(res.variable_);
     }
 
     return params;
diff --git a/typescript/core/helpers.cpp b/typescript/core/helpers.cpp
index 18d6640aa6f30463d60fda0df39fc126141f0a34..bfad37a13a0337d79d2c9e154775baf2c1535e21 100644
--- a/typescript/core/helpers.cpp
+++ b/typescript/core/helpers.cpp
@@ -55,9 +55,9 @@ void Checker::CheckReferenceExpression(const ir::Expression *expr, const char *i
     if (expr->IsIdentifier()) {
         const util::StringView &name = expr->AsIdentifier()->Name();
         binder::ScopeFindResult result = scope_->Find(name);
-        ASSERT(result.variable);
+        ASSERT(result.variable_);
 
-        if (result.variable->HasFlag(binder::VariableFlags::ENUM_LITERAL)) {
+        if (result.variable_->HasFlag(binder::VariableFlags::ENUM_LITERAL)) {
             ThrowTypeError({"Cannot assign to '", name, "' because it is not a variable."}, expr->Start());
         }
     } else if (!expr->IsMemberExpression()) {
@@ -88,18 +88,18 @@ void Checker::CheckTestingKnownTruthyCallableOrAwaitableType(const ir::Expressio
 
     if (location->IsIdentifier()) {
         result = scope_->Find(location->AsIdentifier()->Name(), binder::ResolveBindingOptions::ALL);
-        ASSERT(result.variable);
-        testVar = result.variable;
+        ASSERT(result.variable_);
+        testVar = result.variable_;
     } else if (location->IsBinaryExpression() && location->AsBinaryExpression()->Right()->IsIdentifier()) {
         result = scope_->Find(location->AsBinaryExpression()->Right()->AsIdentifier()->Name(),
                               binder::ResolveBindingOptions::ALL);
-        ASSERT(result.variable);
-        testVar = result.variable;
+        ASSERT(result.variable_);
+        testVar = result.variable_;
     } else if (location->IsAssignmentExpression() && location->AsAssignmentExpression()->Right()->IsIdentifier()) {
         result = scope_->Find(location->AsAssignmentExpression()->Right()->AsIdentifier()->Name(),
                               binder::ResolveBindingOptions::ALL);
-        ASSERT(result.variable);
-        testVar = result.variable;
+        ASSERT(result.variable_);
+        testVar = result.variable_;
     } else if (location->IsMemberExpression() && !location->AsMemberExpression()->IsComputed()) {
         testVar = ResolveNonComputedObjectProperty(location->AsMemberExpression());
     }
@@ -231,8 +231,8 @@ bool Checker::IsVariableUsedInConditionBody(const ir::AstNode *parent, binder::V
             resultVar = ResolveNonComputedObjectProperty(childNode->AsMemberExpression());
         } else if (childNode->IsIdentifier()) {
             binder::ScopeFindResult result = scope_->Find(childNode->AsIdentifier()->Name());
-            ASSERT(result.variable);
-            resultVar = result.variable;
+            ASSERT(result.variable_);
+            resultVar = result.variable_;
         }
 
         if (searchVar == resultVar) {
@@ -255,8 +255,8 @@ bool Checker::FindVariableInBinaryExpressionChain(const ir::AstNode *parent, bin
     parent->Iterate([this, searchVar, &found](const ir::AstNode *childNode) -> void {
         if (childNode->IsIdentifier()) {
             binder::ScopeFindResult result = scope_->Find(childNode->AsIdentifier()->Name());
-            ASSERT(result.variable);
-            if (result.variable == searchVar) {
+            ASSERT(result.variable_);
+            if (result.variable_ == searchVar) {
                 found = true;
                 return;
             }
diff --git a/typescript/core/object.cpp b/typescript/core/object.cpp
index 917e5b2ab6f1d10db8a7addea378f9776fdfb39f..a29cc8189cb4f24dc4984382ecd023bf89b5c8b2 100644
--- a/typescript/core/object.cpp
+++ b/typescript/core/object.cpp
@@ -44,43 +44,43 @@ ObjectLiteralPropertyInfo Checker::HandleObjectLiteralProperty(const ir::Propert
 
     const ir::Expression *propValue = prop->Value();
     // TODO(aszilagyi): params readonly, readonly
-    propInfo.propType = shorthand ? GlobalAnyType() : propValue->Check(this);
+    propInfo.prop_type_ = shorthand ? GlobalAnyType() : propValue->Check(this);
 
     if (prop->Kind() == ir::PropertyKind::GET) {
         const ir::ScriptFunction *func = prop->Value()->AsFunctionExpression()->Function();
         CheckAllCodePathsInNonVoidFunctionReturnOrThrow(func, prop->Start(), "A 'get' accessor must return a value.");
 
-        ASSERT(propInfo.propType->AsObjectType()->IsFunctionType());
-        propInfo.propType = propInfo.propType->AsObjectType()->CallSignatures()[0]->ReturnType();
+        ASSERT(propInfo.prop_type_->AsObjectType()->IsFunctionType());
+        propInfo.prop_type_ = propInfo.prop_type_->AsObjectType()->CallSignatures()[0]->ReturnType();
     } else if (prop->Kind() == ir::PropertyKind::SET) {
-        ASSERT(propInfo.propType->AsObjectType()->IsFunctionType());
-        propInfo.propType = propInfo.propType->AsObjectType()->CallSignatures()[0]->Params()[0]->TsType();
+        ASSERT(propInfo.prop_type_->AsObjectType()->IsFunctionType());
+        propInfo.prop_type_ = propInfo.prop_type_->AsObjectType()->CallSignatures()[0]->Params()[0]->TsType();
     }
 
     if (!readonly) {
-        propInfo.propType = GetBaseTypeOfLiteralType(propInfo.propType);
+        propInfo.prop_type_ = GetBaseTypeOfLiteralType(propInfo.prop_type_);
     }
 
     if (computed) {
-        propInfo.propName = HandleComputedPropertyName(prop->Key(), desc, propInfo.propType, stringIndexTypes,
-                                                       &propInfo.handleNextProp, prop->Start(), readonly);
+        propInfo.prop_name_ = HandleComputedPropertyName(prop->Key(), desc, propInfo.prop_type_, stringIndexTypes,
+                                                         &propInfo.handle_next_prop_, prop->Start(), readonly);
 
-        if (propInfo.handleNextProp) {
+        if (propInfo.handle_next_prop_) {
             return propInfo;
         }
     } else {
-        propInfo.propName = ToPropertyName(prop->Key(), TypeFlag::COMPUTED_TYPE_LITERAL_NAME);
+        propInfo.prop_name_ = ToPropertyName(prop->Key(), TypeFlag::COMPUTED_TYPE_LITERAL_NAME);
     }
 
     if (shorthand) {
-        binder::ScopeFindResult result = scope_->Find(propInfo.propName);
-        if (!result.variable) {
-            ThrowTypeError({"No value exists in scope for the shorthand property '", propInfo.propName,
+        binder::ScopeFindResult result = scope_->Find(propInfo.prop_name_);
+        if (!result.variable_) {
+            ThrowTypeError({"No value exists in scope for the shorthand property '", propInfo.prop_name_,
                             "'. Either declare one ", "or provide an initializer."},
                            prop->Start());
         } else {
             // TODO(aszilagyi): param readonly
-            propInfo.propType = prop->Key()->Check(this);
+            propInfo.prop_type_ = prop->Key()->Check(this);
         }
     }
 
@@ -97,7 +97,7 @@ void Checker::HandleSpreadElement(const ir::SpreadElement *spreadElem, ObjectDes
 
     Type *spreadType = nullptr;
     binder::ScopeFindResult result = scope_->Find(spreadElem->Argument()->AsIdentifier()->Name());
-    if (!result.variable) {
+    if (!result.variable_) {
         ThrowTypeError("Cannot find name ", locInfo);
     }
 
@@ -120,7 +120,7 @@ void Checker::HandleSpreadElement(const ir::SpreadElement *spreadElem, ObjectDes
             if (readonly) {
                 var->AddFlag(binder::VariableFlags::READONLY);
             }
-            desc->properties.push_back(var);
+            desc->properties_.push_back(var);
         }
     }
 
@@ -133,7 +133,7 @@ void Checker::HandleSpreadElement(const ir::SpreadElement *spreadElem, ObjectDes
                     res->SetTsType(prop->TsType());
                 } else {
                     auto *var = binder::Scope::CreateVar(allocator_, prop->Name(), prop->Flags(), nullptr);
-                    desc->properties.push_back(var);
+                    desc->properties_.push_back(var);
                 }
             }
         }
@@ -148,7 +148,7 @@ Type *Checker::CollectStringIndexInfoTypes(const ObjectDescriptor *desc, const s
 
     std::vector<Type *> collectedTypes;
 
-    for (const auto *it : desc->properties) {
+    for (const auto *it : desc->properties_) {
         if (it->TsType()->IsUnionType()) {
             const auto &constituentTypes = it->TsType()->AsUnionType()->ConstituentTypes();
             for (auto *type : constituentTypes) {
@@ -170,15 +170,15 @@ Type *Checker::CollectStringIndexInfoTypes(const ObjectDescriptor *desc, const s
         }
     }
 
-    if (desc->numberIndexInfo) {
-        if (desc->numberIndexInfo->InfoType()->IsUnionType()) {
+    if (desc->number_index_info_) {
+        if (desc->number_index_info_->InfoType()->IsUnionType()) {
             std::vector<Type *> &constituentTypes =
-                desc->numberIndexInfo->InfoType()->AsUnionType()->ConstituentTypes();
+                desc->number_index_info_->InfoType()->AsUnionType()->ConstituentTypes();
             for (auto *type : constituentTypes) {
                 collectedTypes.push_back(type);
             }
         } else {
-            collectedTypes.push_back(desc->numberIndexInfo->InfoType());
+            collectedTypes.push_back(desc->number_index_info_->InfoType());
         }
     }
 
@@ -370,7 +370,7 @@ void Checker::PrefetchTypeLiteralProperties(const ir::Expression *current, check
         prop->AddFlag(binder::VariableFlags::METHOD);
     }
 
-    desc->properties.push_back(prop);
+    desc->properties_.push_back(prop);
 }
 
 void Checker::CheckTsTypeLiteralOrInterfaceMember(const ir::Expression *current, ObjectDescriptor *desc)
@@ -557,29 +557,29 @@ void Checker::CheckTsIndexSignature(const ir::TSIndexSignature *indexSignature,
     Type *indexType = indexSignature->TypeAnnotation()->Check(this);
 
     if (indexSignature->Kind() == ir::TSIndexSignature::TSIndexSignatureKind::NUMBER) {
-        if (desc->numberIndexInfo) {
+        if (desc->number_index_info_) {
             ThrowTypeError("Duplicate number index signature", indexSignature->Start());
         }
 
-        desc->numberIndexInfo = allocator_->New<IndexInfo>(indexType, paramName, indexSignature->Readonly());
+        desc->number_index_info_ = allocator_->New<IndexInfo>(indexType, paramName, indexSignature->Readonly());
 
-        if (desc->stringIndexInfo) {
-            IsTypeAssignableTo(indexType, desc->stringIndexInfo->InfoType(),
+        if (desc->string_index_info_) {
+            IsTypeAssignableTo(indexType, desc->string_index_info_->InfoType(),
                                {"Numeric index type '", indexType, "' is not assignable to string index type '",
-                                desc->stringIndexInfo->InfoType(), "'"},
+                                desc->string_index_info_->InfoType(), "'"},
                                indexSignature->Start());
         }
     } else {
         ASSERT(indexSignature->Kind() == ir::TSIndexSignature::TSIndexSignatureKind::STRING);
-        if (desc->stringIndexInfo) {
+        if (desc->string_index_info_) {
             ThrowTypeError("Duplicate string index signature", indexSignature->Start());
         }
 
-        desc->stringIndexInfo = allocator_->New<IndexInfo>(indexType, paramName, indexSignature->Readonly());
+        desc->string_index_info_ = allocator_->New<IndexInfo>(indexType, paramName, indexSignature->Readonly());
 
-        if (desc->numberIndexInfo) {
-            IsTypeAssignableTo(desc->numberIndexInfo->InfoType(), indexType,
-                               {"Numeric index type '", desc->numberIndexInfo->InfoType(),
+        if (desc->number_index_info_) {
+            IsTypeAssignableTo(desc->number_index_info_->InfoType(), indexType,
+                               {"Numeric index type '", desc->number_index_info_->InfoType(),
                                 "' is not assignable to string index type '", indexType, "'"},
                                indexSignature->Start());
         }
@@ -601,9 +601,9 @@ void Checker::CheckTsSignatureDeclaration(const ir::TSSignatureDeclaration *sign
     auto *signature = allocator_->New<Signature>(signatureInfo, returnType);
 
     if (signatureNode->Kind() == ir::TSSignatureDeclaration::TSSignatureDeclarationKind::CALL_SIGNATURE) {
-        desc->callSignatures.push_back(signature);
+        desc->call_signatures_.push_back(signature);
     } else {
-        desc->constructSignatures.push_back(signature);
+        desc->construct_signatures_.push_back(signature);
     }
 }
 
@@ -647,16 +647,16 @@ void Checker::CheckTsPropertyOrMethodSignature(const ir::Expression *current, Ob
 
 void Checker::HandleNumberIndexInfo(ObjectDescriptor *desc, Type *indexType, bool readonly)
 {
-    if (desc->numberIndexInfo) {
-        if (desc->numberIndexInfo->InfoType()->IsUnionType()) {
-            desc->numberIndexInfo->InfoType()->AsUnionType()->AddConstituentType(indexType, relation_);
+    if (desc->number_index_info_) {
+        if (desc->number_index_info_->InfoType()->IsUnionType()) {
+            desc->number_index_info_->InfoType()->AsUnionType()->AddConstituentType(indexType, relation_);
         } else {
-            Type *numIndexType = CreateUnionType({desc->numberIndexInfo->InfoType(), indexType});
-            desc->numberIndexInfo->SetInfoType(numIndexType);
+            Type *numIndexType = CreateUnionType({desc->number_index_info_->InfoType(), indexType});
+            desc->number_index_info_->SetInfoType(numIndexType);
         }
     } else {
         auto *numIndexInfo = allocator_->New<IndexInfo>(indexType, "x", readonly);
-        desc->numberIndexInfo = numIndexInfo;
+        desc->number_index_info_ = numIndexInfo;
     }
 }
 
@@ -669,7 +669,7 @@ util::StringView Checker::HandleComputedPropertyName(const ir::Expression *propK
     if (propKey->IsIdentifier()) {
         const ir::Identifier *identKey = propKey->AsIdentifier();
         binder::ScopeFindResult result = scope_->Find(identKey->Name());
-        if (!result.variable) {
+        if (!result.variable_) {
             ThrowTypeError({"Cannot find name '", identKey->Name(), "'"}, locInfo);
         }
 
diff --git a/typescript/core/typeCreation.cpp b/typescript/core/typeCreation.cpp
index 1b3aab4d5f5f584e2d10fc36d8040a49d5d76f42..e309aa904de80d8fddcf70d0bc0ac7435e8e80a9 100644
--- a/typescript/core/typeCreation.cpp
+++ b/typescript/core/typeCreation.cpp
@@ -20,37 +20,37 @@ namespace panda::es2panda::checker {
 
 Type *Checker::CreateNumberLiteralType(double value)
 {
-    auto search = numberLiteralMap_.find(value);
-    if (search != numberLiteralMap_.end()) {
+    auto search = number_literal_map_.find(value);
+    if (search != number_literal_map_.end()) {
         return search->second;
     }
 
     auto *newNumLiteralType = allocator_->New<NumberLiteralType>(value);
-    numberLiteralMap_.insert({value, newNumLiteralType});
+    number_literal_map_.insert({value, newNumLiteralType});
     return newNumLiteralType;
 }
 
 Type *Checker::CreateBigintLiteralType(const util::StringView &str, bool negative)
 {
-    auto search = bigintLiteralMap_.find(str);
-    if (search != bigintLiteralMap_.end()) {
+    auto search = bigint_literal_map_.find(str);
+    if (search != bigint_literal_map_.end()) {
         return search->second;
     }
 
     auto *newBigiLiteralType = allocator_->New<BigintLiteralType>(str, negative);
-    bigintLiteralMap_.insert({str, newBigiLiteralType});
+    bigint_literal_map_.insert({str, newBigiLiteralType});
     return newBigiLiteralType;
 }
 
 Type *Checker::CreateStringLiteralType(const util::StringView &str)
 {
-    auto search = stringLiteralMap_.find(str);
-    if (search != stringLiteralMap_.end()) {
+    auto search = string_literal_map_.find(str);
+    if (search != string_literal_map_.end()) {
         return search->second;
     }
 
     auto *newStrLiteralType = allocator_->New<StringLiteralType>(str);
-    stringLiteralMap_.insert({str, newStrLiteralType});
+    string_literal_map_.insert({str, newStrLiteralType});
     return newStrLiteralType;
 }
 
@@ -74,7 +74,7 @@ Type *Checker::CreateUnionType(std::vector<Type *> &&constituentTypes)
 
     auto *newUnionType = allocator_->New<UnionType>(std::move(constituentTypes));
 
-    return UnionType::HandleUnionType(newUnionType, globalTypes_);
+    return UnionType::HandleUnionType(newUnionType, global_types_);
 }
 
 Type *Checker::CreateFunctionTypeWithSignature(Signature *callSignature)
@@ -94,7 +94,7 @@ Type *Checker::CreateConstructorTypeWithSignature(Signature *constructSignature)
 Type *Checker::CreateTupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
                                uint32_t minLength, uint32_t fixedLength, bool readonly)
 {
-    desc->stringIndexInfo = allocator_->New<IndexInfo>(GlobalAnyType(), "x");
+    desc->string_index_info_ = allocator_->New<IndexInfo>(GlobalAnyType(), "x");
 
     auto *tupleType =
         allocator_->New<TupleType>(desc, std::move(elementFlags), combinedFlags, minLength, fixedLength, readonly);
@@ -106,7 +106,7 @@ Type *Checker::CreateTupleType(ObjectDescriptor *desc, TupleElementFlagPool &&el
                                uint32_t minLength, uint32_t fixedLength, bool readonly,
                                NamedTupleMemberPool &&namedMembers)
 {
-    desc->stringIndexInfo = allocator_->New<IndexInfo>(GlobalAnyType(), "x");
+    desc->string_index_info_ = allocator_->New<IndexInfo>(GlobalAnyType(), "x");
     ObjectType *tupleType = nullptr;
 
     if (!namedMembers.empty()) {
diff --git a/typescript/core/typeElaboration.cpp b/typescript/core/typeElaboration.cpp
index 61cd7c2be45f189b5531ae52e91ed122a68e3dd8..322c117ee97be85830c84e17dea598a3bcaab546 100644
--- a/typescript/core/typeElaboration.cpp
+++ b/typescript/core/typeElaboration.cpp
@@ -82,7 +82,7 @@ bool Checker::ElaborateObjectLiteral(TypeOrNode source, const Type *targetType,
     }
 
     ObjectLiteralElaborationData elaborationData;
-    elaborationData.desc = allocator_->New<ObjectDescriptor>();
+    elaborationData.desc_ = allocator_->New<ObjectDescriptor>();
     GetPotentialTypesAndIndexInfosForElaboration(targetType, &elaborationData);
 
     if (sourceNode) {
@@ -92,11 +92,11 @@ bool Checker::ElaborateObjectLiteral(TypeOrNode source, const Type *targetType,
         }
 
         if (excessCheckNeeded) {
-            for (const auto *it : elaborationData.spreads) {
-                HandleSpreadElement(it->AsSpreadElement(), elaborationData.desc, it->Start());
+            for (const auto *it : elaborationData.spreads_) {
+                HandleSpreadElement(it->AsSpreadElement(), elaborationData.desc_, it->Start());
             }
 
-            Type *sourceObjType = allocator_->New<ObjectLiteralType>(elaborationData.desc);
+            Type *sourceObjType = allocator_->New<ObjectLiteralType>(elaborationData.desc_);
 
             IsTypeAssignableTo(sourceObjType, targetType,
                                {"Type '", sourceObjType, "' is not assignable to type '", targetType, "'."}, locInfo);
@@ -106,7 +106,7 @@ bool Checker::ElaborateObjectLiteral(TypeOrNode source, const Type *targetType,
     }
 
     ASSERT(sourceType);
-    ElaborateObjectLiteralWithType(sourceType, targetType, elaborationData.potentialObjectTypes, locInfo);
+    ElaborateObjectLiteralWithType(sourceType, targetType, elaborationData.potential_object_types_, locInfo);
 
     return true;
 }
@@ -130,7 +130,7 @@ void Checker::GetPotentialTypesAndIndexInfosForElaboration(const Type *targetTyp
                     numberInfoTypes.push_back(infoTypePair.second);
                 }
 
-                elaborationData->potentialObjectTypes.insert({it->Id(), it->AsObjectType()});
+                elaborationData->potential_object_types_.insert({it->Id(), it->AsObjectType()});
             }
         }
 
@@ -144,13 +144,13 @@ void Checker::GetPotentialTypesAndIndexInfosForElaboration(const Type *targetTyp
             stringInfosType = CreateUnionType(std::move(stringInfoTypes));
         }
 
-        elaborationData->numberInfosType = numberInfosType;
-        elaborationData->stringInfosType = stringInfosType;
+        elaborationData->number_infos_type_ = numberInfosType;
+        elaborationData->string_infos_type_ = stringInfosType;
     } else {
         IndexInfoTypePair infoTypePair = GetIndexInfoTypePair(targetType->AsObjectType());
 
-        elaborationData->stringInfosType = infoTypePair.first;
-        elaborationData->numberInfosType = infoTypePair.second;
+        elaborationData->string_infos_type_ = infoTypePair.first;
+        elaborationData->number_infos_type_ = infoTypePair.second;
     }
 }
 
@@ -177,7 +177,7 @@ bool Checker::CheckIfExcessTypeCheckNeededForObjectElaboration(const Type *targe
                                                                ObjectLiteralElaborationData *elaborationData)
 {
     if (targetType->IsUnionType()) {
-        for (auto it : elaborationData->potentialObjectTypes) {
+        for (auto it : elaborationData->potential_object_types_) {
             if (!it.second->CallSignatures().empty() || !it.second->ConstructSignatures().empty()) {
                 return true;
             }
@@ -190,7 +190,7 @@ bool Checker::CheckIfExcessTypeCheckNeededForObjectElaboration(const Type *targe
     if (targetType->IsUnionType()) {
         uint32_t targetPropCount = 0;
 
-        for (auto it : elaborationData->potentialObjectTypes) {
+        for (auto it : elaborationData->potential_object_types_) {
             targetPropCount = it.second->Properties().size();
 
             if (it.second->IsInterfaceType()) {
@@ -199,7 +199,7 @@ bool Checker::CheckIfExcessTypeCheckNeededForObjectElaboration(const Type *targe
                 targetPropCount += interfaceProperties.size();
             }
 
-            if (elaborationData->desc->properties.size() < targetPropCount) {
+            if (elaborationData->desc_->properties_.size() < targetPropCount) {
                 return true;
             }
         }
@@ -212,7 +212,7 @@ bool Checker::CheckIfExcessTypeCheckNeededForObjectElaboration(const Type *targe
             targetPropCount += interfaceProperties.size();
         }
 
-        if (elaborationData->desc->properties.size() < targetPropCount) {
+        if (elaborationData->desc_->properties_.size() < targetPropCount) {
             return true;
         }
     }
@@ -228,15 +228,15 @@ bool Checker::ElaborateObjectLiteralWithNode(const ir::ObjectExpression *sourceN
     for (auto *sourceProp : sourceNode->Properties()) {
         if (!sourceProp->IsProperty()) {
             ASSERT(sourceProp->IsSpreadElement());
-            elaborationData->spreads.push_back(sourceProp->AsSpreadElement());
+            elaborationData->spreads_.push_back(sourceProp->AsSpreadElement());
             excessCheckNeeded = true;
             continue;
         }
         const ir::Property *currentProp = sourceProp->AsProperty();
 
         ObjectLiteralPropertyInfo propInfo =
-            HandleObjectLiteralProperty(currentProp, elaborationData->desc, &elaborationData->stringIndexTypes);
-        if (propInfo.handleNextProp) {
+            HandleObjectLiteralProperty(currentProp, elaborationData->desc_, &elaborationData->string_index_types_);
+        if (propInfo.handle_next_prop_) {
             excessCheckNeeded = true;
             continue;
         }
@@ -244,38 +244,38 @@ bool Checker::ElaborateObjectLiteralWithNode(const ir::ObjectExpression *sourceN
         bool numberLiteralName = currentProp->Key()->IsNumberLiteral();
 
         Type *targetPropType = GetTargetPropertyTypeFromTargetForElaborationWithNode(
-            targetType, elaborationData, propInfo.propName, currentProp->Value());
+            targetType, elaborationData, propInfo.prop_name_, currentProp->Value());
 
         if (!targetPropType) {
             targetPropType =
-                GetindexInfoTypeOrThrowError(targetType, elaborationData, propInfo.propName, currentProp->IsComputed(),
-                                             numberLiteralName, sourceProp->Start());
+                GetindexInfoTypeOrThrowError(targetType, elaborationData, propInfo.prop_name_,
+                                             currentProp->IsComputed(), numberLiteralName, sourceProp->Start());
         }
 
         if (!IsLiteralType(targetPropType) || targetPropType->IsBooleanType()) {
-            propInfo.propType = GetBaseTypeOfLiteralType(propInfo.propType);
+            propInfo.prop_type_ = GetBaseTypeOfLiteralType(propInfo.prop_type_);
         }
 
         if (!ElaborateElementwise(currentProp->Value(), targetPropType, sourceProp->Start()) &&
-            !IsTypeAssignableTo(propInfo.propType, targetPropType)) {
+            !IsTypeAssignableTo(propInfo.prop_type_, targetPropType)) {
             if (currentProp->IsComputed() && currentProp->Key()->IsIdentifier()) {
-                ThrowTypeError({"Type of computed property's value is '", propInfo.propType,
+                ThrowTypeError({"Type of computed property's value is '", propInfo.prop_type_,
                                 "', which is not assignable to type '", targetPropType, "'."},
                                sourceProp->Start());
             } else {
-                ThrowTypeError({"Type '", propInfo.propType, "' is not assignable to type '", targetPropType, "'."},
+                ThrowTypeError({"Type '", propInfo.prop_type_, "' is not assignable to type '", targetPropType, "'."},
                                sourceProp->Start());
             }
         }
 
         auto *objLitProp =
-            binder::Scope::CreateVar(allocator_, propInfo.propName, binder::VariableFlags::NONE, currentProp);
+            binder::Scope::CreateVar(allocator_, propInfo.prop_name_, binder::VariableFlags::NONE, currentProp);
 
         objLitProp->AddFlag(currentProp->IsMethod() ? binder::VariableFlags::METHOD : binder::VariableFlags::PROPERTY);
-        propInfo.propType->SetVariable(objLitProp);
-        propInfo.propType->AddTypeFlag(TypeFlag::RELATION_CHECKED);
-        objLitProp->SetTsType(propInfo.propType);
-        elaborationData->desc->properties.push_back(objLitProp);
+        propInfo.prop_type_->SetVariable(objLitProp);
+        propInfo.prop_type_->AddTypeFlag(TypeFlag::RELATION_CHECKED);
+        objLitProp->SetTsType(propInfo.prop_type_);
+        elaborationData->desc_->properties_.push_back(objLitProp);
     }
 
     return excessCheckNeeded;
@@ -285,8 +285,8 @@ Type *Checker::GetindexInfoTypeOrThrowError(const Type *targetType, ObjectLitera
                                             const util::StringView &propName, bool computed, bool numberLiteralName,
                                             lexer::SourcePosition locInfo)
 {
-    if ((!elaborationData->stringInfosType && !elaborationData->numberInfosType) ||
-        (!numberLiteralName && !elaborationData->stringInfosType)) {
+    if ((!elaborationData->string_infos_type_ && !elaborationData->number_infos_type_) ||
+        (!numberLiteralName && !elaborationData->string_infos_type_)) {
         std::stringstream ss;
         if (computed) {
             ss << "[" << propName << "]";
@@ -301,11 +301,11 @@ Type *Checker::GetindexInfoTypeOrThrowError(const Type *targetType, ObjectLitera
                        locInfo);
     }
 
-    if (numberLiteralName && elaborationData->numberInfosType) {
-        return elaborationData->numberInfosType;
+    if (numberLiteralName && elaborationData->number_infos_type_) {
+        return elaborationData->number_infos_type_;
     }
 
-    return elaborationData->stringInfosType;
+    return elaborationData->string_infos_type_;
 }
 
 void Checker::ElaborateObjectLiteralWithType(const ObjectLiteralType *sourceType, const Type *targetType,
@@ -341,8 +341,8 @@ Type *Checker::GetTargetPropertyTypeFromTargetForElaborationWithNode(const Type
 
     if (targetType->IsUnionType()) {
         std::vector<Type *> targetPropTypes;
-        for (auto potentialType = elaborationData->potentialObjectTypes.begin();
-             potentialType != elaborationData->potentialObjectTypes.end();) {
+        for (auto potentialType = elaborationData->potential_object_types_.begin();
+             potentialType != elaborationData->potential_object_types_.end();) {
             searchProp = potentialType->second->GetProperty(propName);
             if (searchProp) {
                 if (searchProp->TsType()->IsUnionType()) {
@@ -354,7 +354,7 @@ Type *Checker::GetTargetPropertyTypeFromTargetForElaborationWithNode(const Type
                 }
 
                 if (!IsTypeAssignableTo(CreateTupleTypeFromEveryArrayExpression(propValue), searchProp->TsType())) {
-                    potentialType = elaborationData->potentialObjectTypes.erase(potentialType);
+                    potentialType = elaborationData->potential_object_types_.erase(potentialType);
                     continue;
                 }
 
@@ -362,7 +362,7 @@ Type *Checker::GetTargetPropertyTypeFromTargetForElaborationWithNode(const Type
                 continue;
             }
 
-            potentialType = elaborationData->potentialObjectTypes.erase(potentialType);
+            potentialType = elaborationData->potential_object_types_.erase(potentialType);
         }
 
         if (targetPropTypes.empty()) {
@@ -676,7 +676,7 @@ Type *Checker::GetUnaryResultType(Type *operandType)
 
 Type *Checker::InferVariableDeclarationType(const ir::Identifier *decl)
 {
-    if (!typeStack_.insert(decl).second) {
+    if (!type_stack_.insert(decl).second) {
         if (decl->TypeAnnotation()) {
             ThrowTypeError({"'", decl->Name(),
                             "' is referenced directly or indirectly in its "
diff --git a/typescript/types/constructorType.cpp b/typescript/types/constructorType.cpp
index a4e91da1d019472e239bcbd4000a936253d2174c..f87c9d476703524a1d5f1b140084197010ccefda 100644
--- a/typescript/types/constructorType.cpp
+++ b/typescript/types/constructorType.cpp
@@ -23,18 +23,18 @@ ConstructorType::ConstructorType(ObjectDescriptor *desc) : ObjectType(ObjectType
 
 void ConstructorType::ToString(std::stringstream &ss) const
 {
-    if (desc_->constructSignatures.size() > 1) {
+    if (desc_->construct_signatures_.size() > 1) {
         ss << "{ ";
     }
 
-    for (auto it = desc_->constructSignatures.begin(); it != desc_->constructSignatures.end(); it++) {
+    for (auto it = desc_->construct_signatures_.begin(); it != desc_->construct_signatures_.end(); it++) {
         (*it)->ToString(ss, variable_);
-        if (std::next(it) != desc_->constructSignatures.end()) {
+        if (std::next(it) != desc_->construct_signatures_.end()) {
             ss << ", ";
         }
     }
 
-    if (desc_->constructSignatures.size() > 1) {
+    if (desc_->construct_signatures_.size() > 1) {
         ss << " }";
     }
 }
diff --git a/typescript/types/enumType.cpp b/typescript/types/enumType.cpp
index 040b2b35c1c0ec6eccccdca9351c28c4b2daba70..ed42501e079091962b4d3626cec01fc82cf3218c 100644
--- a/typescript/types/enumType.cpp
+++ b/typescript/types/enumType.cpp
@@ -20,23 +20,23 @@
 namespace panda::es2panda::checker {
 
 EnumType::EnumType(binder::Variable *enumLiteralVar, binder::EnumVariable *enumVar)
-    : Type(TypeFlag::ENUM), enumLiteralVar_(enumLiteralVar), enumVar_(enumVar)
+    : Type(TypeFlag::ENUM), enum_literal_var_(enumLiteralVar), enum_var_(enumVar)
 {
 }
 
 const binder::Variable *EnumType::EnumLiteralVar() const
 {
-    return enumLiteralVar_;
+    return enum_literal_var_;
 }
 
 const binder::EnumVariable *EnumType::EnumVar() const
 {
-    return enumVar_;
+    return enum_var_;
 }
 
 void EnumType::ToString(std::stringstream &ss) const
 {
-    ss << enumLiteralVar_->Name() << "." << enumVar_->Name();
+    ss << enum_literal_var_->Name() << "." << enum_var_->Name();
 }
 
 void EnumType::Identical([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *other) const
diff --git a/typescript/types/enumType.h b/typescript/types/enumType.h
index 1038eba2a581ac8e5b9743f1b5913e1c847d7fb3..b16e3af1b64dee57f39f9f50096208fc60398eb8 100644
--- a/typescript/types/enumType.h
+++ b/typescript/types/enumType.h
@@ -38,8 +38,8 @@ public:
     Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
 
 private:
-    binder::Variable *enumLiteralVar_;
-    binder::EnumVariable *enumVar_;
+    binder::Variable *enum_literal_var_;
+    binder::EnumVariable *enum_var_;
 };
 
 }  // namespace panda::es2panda::checker
diff --git a/typescript/types/functionType.cpp b/typescript/types/functionType.cpp
index bdad12e4db3ca7f6d5a2986003daa5befbb3672d..b788615687445a987539349a06c8a1c979bbc4cc 100644
--- a/typescript/types/functionType.cpp
+++ b/typescript/types/functionType.cpp
@@ -33,18 +33,18 @@ void FunctionType::ToString(std::stringstream &ss) const
 
     stack.insert(this);
 
-    if (desc_->callSignatures.size() > 1) {
+    if (desc_->call_signatures_.size() > 1) {
         ss << "{ ";
     }
 
-    for (auto it = desc_->callSignatures.begin(); it != desc_->callSignatures.end(); it++) {
-        (*it)->ToString(ss, variable_, desc_->callSignatures.size() > 1);
-        if (std::next(it) != desc_->callSignatures.end()) {
+    for (auto it = desc_->call_signatures_.begin(); it != desc_->call_signatures_.end(); it++) {
+        (*it)->ToString(ss, variable_, desc_->call_signatures_.size() > 1);
+        if (std::next(it) != desc_->call_signatures_.end()) {
             ss << ", ";
         }
     }
 
-    if (desc_->callSignatures.size() > 1) {
+    if (desc_->call_signatures_.size() > 1) {
         ss << " }";
     }
 }
diff --git a/typescript/types/globalTypesHolder.cpp b/typescript/types/globalTypesHolder.cpp
index c944b943cea04b9cb005b095daf3cb407d8def35..4069d25b153566862f525457795a6fd4ef090363 100644
--- a/typescript/types/globalTypesHolder.cpp
+++ b/typescript/types/globalTypesHolder.cpp
@@ -38,136 +38,136 @@ namespace panda::es2panda::checker {
 
 GlobalTypesHolder::GlobalTypesHolder(ArenaAllocator *allocator)
 {
-    globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER)] = allocator->New<NumberType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::ANY)] = allocator->New<AnyType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::STRING)] = allocator->New<StringType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::BOOLEAN)] = allocator->New<BooleanType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::VOID)] = allocator->New<VoidType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::NULL_ID)] = allocator->New<NullType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::UNDEFINED)] = allocator->New<UndefinedType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::UNKNOWN)] = allocator->New<UnknownType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::NEVER)] = allocator->New<NeverType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE)] = allocator->New<NonPrimitiveType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::BIGINT)] = allocator->New<BigintType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::FALSE_ID)] = allocator->New<BooleanLiteralType>(false);
-    globalTypes_[static_cast<size_t>(GlobalTypeId::TRUE_ID)] = allocator->New<BooleanLiteralType>(true);
-    globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT)] =
+    global_types_[static_cast<size_t>(GlobalTypeId::NUMBER)] = allocator->New<NumberType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::ANY)] = allocator->New<AnyType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::STRING)] = allocator->New<StringType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::BOOLEAN)] = allocator->New<BooleanType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::VOID)] = allocator->New<VoidType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::NULL_ID)] = allocator->New<NullType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::UNDEFINED)] = allocator->New<UndefinedType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::UNKNOWN)] = allocator->New<UnknownType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::NEVER)] = allocator->New<NeverType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE)] = allocator->New<NonPrimitiveType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::BIGINT)] = allocator->New<BigintType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::FALSE_ID)] = allocator->New<BooleanLiteralType>(false);
+    global_types_[static_cast<size_t>(GlobalTypeId::TRUE_ID)] = allocator->New<BooleanLiteralType>(true);
+    global_types_[static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT)] =
         allocator->New<UnionType>(std::initializer_list<Type *> {GlobalNumberType(), GlobalBigintType()});
-    globalTypes_[static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER)] =
+    global_types_[static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER)] =
         allocator->New<UnionType>(std::initializer_list<Type *> {GlobalStringType(), GlobalNumberType()});
-    globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO)] = allocator->New<NumberLiteralType>(0);
-    globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_STRING)] = allocator->New<StringLiteralType>("");
-    globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO_BIGINT)] = allocator->New<BigintLiteralType>("0n", false);
-    globalTypes_[static_cast<size_t>(GlobalTypeId::PRIMITIVE)] = allocator->New<UnionType>(
+    global_types_[static_cast<size_t>(GlobalTypeId::ZERO)] = allocator->New<NumberLiteralType>(0);
+    global_types_[static_cast<size_t>(GlobalTypeId::EMPTY_STRING)] = allocator->New<StringLiteralType>("");
+    global_types_[static_cast<size_t>(GlobalTypeId::ZERO_BIGINT)] = allocator->New<BigintLiteralType>("0n", false);
+    global_types_[static_cast<size_t>(GlobalTypeId::PRIMITIVE)] = allocator->New<UnionType>(
         std::initializer_list<Type *> {GlobalNumberType(), GlobalStringType(), GlobalBigintType(), GlobalBooleanType(),
                                        GlobalVoidType(), GlobalUndefinedType(), GlobalNullType()});
-    globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE)] = allocator->New<TupleType>();
-    globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT)] = allocator->New<ObjectLiteralType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE)] = allocator->New<TupleType>();
+    global_types_[static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT)] = allocator->New<ObjectLiteralType>();
 }
 
 Type *GlobalTypesHolder::GlobalNumberType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::NUMBER));
 }
 
 Type *GlobalTypesHolder::GlobalAnyType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ANY));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::ANY));
 }
 
 Type *GlobalTypesHolder::GlobalStringType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::STRING));
 }
 
 Type *GlobalTypesHolder::GlobalBooleanType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BOOLEAN));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::BOOLEAN));
 }
 
 Type *GlobalTypesHolder::GlobalVoidType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::VOID));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::VOID));
 }
 
 Type *GlobalTypesHolder::GlobalNullType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NULL_ID));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::NULL_ID));
 }
 
 Type *GlobalTypesHolder::GlobalUndefinedType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNDEFINED));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::UNDEFINED));
 }
 
 Type *GlobalTypesHolder::GlobalUnknownType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNKNOWN));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::UNKNOWN));
 }
 
 Type *GlobalTypesHolder::GlobalNeverType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NEVER));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::NEVER));
 }
 
 Type *GlobalTypesHolder::GlobalNonPrimitiveType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE));
 }
 
 Type *GlobalTypesHolder::GlobalBigintType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BIGINT));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::BIGINT));
 }
 
 Type *GlobalTypesHolder::GlobalFalseType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::FALSE_ID));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::FALSE_ID));
 }
 
 Type *GlobalTypesHolder::GlobalTrueType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::TRUE_ID));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::TRUE_ID));
 }
 
 Type *GlobalTypesHolder::GlobalNumberOrBigintType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT));
 }
 
 Type *GlobalTypesHolder::GlobalStringOrNumberType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER));
 }
 
 Type *GlobalTypesHolder::GlobalZeroType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::ZERO));
 }
 
 Type *GlobalTypesHolder::GlobalEmptyStringType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_STRING));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::EMPTY_STRING));
 }
 
 Type *GlobalTypesHolder::GlobalZeroBigintType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO_BIGINT));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::ZERO_BIGINT));
 }
 
 Type *GlobalTypesHolder::GlobalPrimitiveType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::PRIMITIVE));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::PRIMITIVE));
 }
 
 Type *GlobalTypesHolder::GlobalEmptyTupleType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE));
 }
 
 Type *GlobalTypesHolder::GlobalEmptyObjectType()
 {
-    return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT));
+    return global_types_.at(static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT));
 }
 
 }  // namespace panda::es2panda::checker
diff --git a/typescript/types/globalTypesHolder.h b/typescript/types/globalTypesHolder.h
index 83fb925fb4ae75e589326667e2ecc841b884b000..f4810eb727153864b38047250d5cd01746f2198f 100644
--- a/typescript/types/globalTypesHolder.h
+++ b/typescript/types/globalTypesHolder.h
@@ -75,7 +75,7 @@ public:
     Type *GlobalEmptyObjectType();
 
 private:
-    std::array<Type *, static_cast<size_t>(GlobalTypeId::COUNT)> globalTypes_ {};
+    std::array<Type *, static_cast<size_t>(GlobalTypeId::COUNT)> global_types_ {};
 };
 
 }  // namespace panda::es2panda::checker
diff --git a/typescript/types/indexInfo.cpp b/typescript/types/indexInfo.cpp
index 5aad2d190144c3621506368749e444db5db2d0ff..6d9078e9d461b81d9f0975d2496ceb177125f4f3 100644
--- a/typescript/types/indexInfo.cpp
+++ b/typescript/types/indexInfo.cpp
@@ -20,7 +20,7 @@
 namespace panda::es2panda::checker {
 
 IndexInfo::IndexInfo(Type *type, util::StringView paramName, bool readonly)
-    : type_(type), paramName_(paramName), readonly_(readonly)
+    : type_(type), param_name_(paramName), readonly_(readonly)
 {
 }
 
@@ -41,12 +41,12 @@ void IndexInfo::SetInfoType(class Type *type)
 
 const util::StringView &IndexInfo::ParamName()
 {
-    return paramName_;
+    return param_name_;
 }
 
 IndexInfo *IndexInfo::Copy(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
 {
-    return allocator->New<IndexInfo>(type_->Instantiate(allocator, relation, globalTypes), paramName_, readonly_);
+    return allocator->New<IndexInfo>(type_->Instantiate(allocator, relation, globalTypes), param_name_, readonly_);
 }
 
 void IndexInfo::ToString(std::stringstream &ss, bool numIndex) const
@@ -55,7 +55,7 @@ void IndexInfo::ToString(std::stringstream &ss, bool numIndex) const
         ss << "readonly ";
     }
 
-    ss << "[" << paramName_ << ": ";
+    ss << "[" << param_name_ << ": ";
 
     if (numIndex) {
         ss << "number]: ";
diff --git a/typescript/types/indexInfo.h b/typescript/types/indexInfo.h
index c20ee43ae4ca8caf045baa4a6033591109da69a2..3f67bff56770f6fb980ca62f6b2bf3cf04ac6f57 100644
--- a/typescript/types/indexInfo.h
+++ b/typescript/types/indexInfo.h
@@ -40,7 +40,7 @@ public:
 
 private:
     Type *type_;
-    util::StringView paramName_;
+    util::StringView param_name_;
     bool readonly_;
 };
 
diff --git a/typescript/types/interfaceType.cpp b/typescript/types/interfaceType.cpp
index 8f1fbb3057210611ab50799cfeff6c179a7d1b02..01ea0cac172c99a3258da1ec7fe3b0f693ae5c6d 100644
--- a/typescript/types/interfaceType.cpp
+++ b/typescript/types/interfaceType.cpp
@@ -45,22 +45,22 @@ const util::StringView &InterfaceType::Name() const
 
 void InterfaceType::SetMergedTypeParams(std::pair<std::vector<binder::Variable *>, size_t> &&mergedTypeParams)
 {
-    mergedTypeParams_ = std::move(mergedTypeParams);
+    merged_type_params_ = std::move(mergedTypeParams);
 }
 
 const std::pair<std::vector<binder::Variable *>, size_t> &InterfaceType::GetMergedTypeParams() const
 {
-    return mergedTypeParams_;
+    return merged_type_params_;
 }
 
 void InterfaceType::SetTypeParamTypes(std::vector<Type *> &&typeParamTypes)
 {
-    typeParamTypes_ = std::move(typeParamTypes);
+    type_param_types_ = std::move(typeParamTypes);
 }
 
 const std::vector<Type *> &InterfaceType::GetTypeParamTypes() const
 {
-    return typeParamTypes_;
+    return type_param_types_;
 }
 
 binder::LocalVariable *InterfaceType::GetProperty(const util::StringView &name) const
@@ -85,13 +85,13 @@ void InterfaceType::ToString(std::stringstream &ss) const
 {
     ss << name_;
 
-    if (!typeParamTypes_.empty()) {
+    if (!type_param_types_.empty()) {
         ss << "<";
 
-        for (auto it = typeParamTypes_.begin(); it != typeParamTypes_.end(); it++) {
+        for (auto it = type_param_types_.begin(); it != type_param_types_.end(); it++) {
             (*it)->ToString(ss);
 
-            if (std::next(it) != typeParamTypes_.end()) {
+            if (std::next(it) != type_param_types_.end()) {
                 ss << ", ";
             }
         }
@@ -281,8 +281,8 @@ IndexInfo *InterfaceType::FindIndexInfo(bool findNumberInfo)
 
 TypeFacts InterfaceType::GetTypeFacts() const
 {
-    if (desc_->properties.empty() && desc_->callSignatures.empty() && desc_->constructSignatures.empty() &&
-        !desc_->stringIndexInfo && !desc_->numberIndexInfo) {
+    if (desc_->properties_.empty() && desc_->call_signatures_.empty() && desc_->construct_signatures_.empty() &&
+        !desc_->string_index_info_ && !desc_->number_index_info_) {
         if (bases_.empty()) {
             return TypeFacts::EMPTY_OBJECT_FACTS;
         }
diff --git a/typescript/types/interfaceType.h b/typescript/types/interfaceType.h
index f46f3952405ef402abaf4bb424cbb2a922220421..d2b3bca75c27ea956a7cdb6da961bd5e6760d029 100644
--- a/typescript/types/interfaceType.h
+++ b/typescript/types/interfaceType.h
@@ -46,8 +46,8 @@ public:
 private:
     util::StringView name_;
     std::vector<ObjectType *> bases_;
-    std::pair<std::vector<binder::Variable *>, size_t> mergedTypeParams_ {};
-    std::vector<Type *> typeParamTypes_ {};
+    std::pair<std::vector<binder::Variable *>, size_t> merged_type_params_ {};
+    std::vector<Type *> type_param_types_ {};
 };
 
 }  // namespace panda::es2panda::checker
diff --git a/typescript/types/objectDescriptor.cpp b/typescript/types/objectDescriptor.cpp
index 6c1d6004295578c1b7beb323a6dbbbd6c13ab985..e2515d9d8c658303ab6b45c06c04c7bab97d8f73 100644
--- a/typescript/types/objectDescriptor.cpp
+++ b/typescript/types/objectDescriptor.cpp
@@ -23,7 +23,7 @@ namespace panda::es2panda::checker {
 
 binder::LocalVariable *ObjectDescriptor::FindProperty(const util::StringView &name) const
 {
-    for (auto *it : properties) {
+    for (auto *it : properties_) {
         if (it->Name() == name) {
             return it;
         }
@@ -34,46 +34,46 @@ binder::LocalVariable *ObjectDescriptor::FindProperty(const util::StringView &na
 
 ObjectDescriptor::~ObjectDescriptor()
 {
-    for (auto *it : properties) {
+    for (auto *it : properties_) {
         delete it;
     }
 
-    for (auto *it : callSignatures) {
+    for (auto *it : call_signatures_) {
         delete it;
     }
 
-    for (auto *it : constructSignatures) {
+    for (auto *it : construct_signatures_) {
         delete it;
     }
 
-    delete stringIndexInfo;
-    delete numberIndexInfo;
+    delete string_index_info_;
+    delete number_index_info_;
 }
 
 void ObjectDescriptor::Copy(ArenaAllocator *allocator, ObjectDescriptor *copiedDesc, TypeRelation *relation,
                             GlobalTypesHolder *globalTypes)
 {
     // kézzel másolás
-    for (auto *it : properties) {
+    for (auto *it : properties_) {
         auto *copiedProp = it->Copy(allocator, it->Declaration());
         copiedProp->SetTsType(it->TsType()->Instantiate(allocator, relation, globalTypes));
-        copiedDesc->properties.push_back(copiedProp);
+        copiedDesc->properties_.push_back(copiedProp);
     }
 
-    for (auto *it : callSignatures) {
-        copiedDesc->callSignatures.push_back(it->Copy(allocator, relation, globalTypes));
+    for (auto *it : call_signatures_) {
+        copiedDesc->call_signatures_.push_back(it->Copy(allocator, relation, globalTypes));
     }
 
-    for (auto *it : constructSignatures) {
-        copiedDesc->constructSignatures.push_back(it->Copy(allocator, relation, globalTypes));
+    for (auto *it : construct_signatures_) {
+        copiedDesc->construct_signatures_.push_back(it->Copy(allocator, relation, globalTypes));
     }
 
-    if (numberIndexInfo) {
-        copiedDesc->numberIndexInfo = numberIndexInfo->Copy(allocator, relation, globalTypes);
+    if (number_index_info_) {
+        copiedDesc->number_index_info_ = number_index_info_->Copy(allocator, relation, globalTypes);
     }
 
-    if (stringIndexInfo) {
-        copiedDesc->stringIndexInfo = stringIndexInfo->Copy(allocator, relation, globalTypes);
+    if (string_index_info_) {
+        copiedDesc->string_index_info_ = string_index_info_->Copy(allocator, relation, globalTypes);
     }
 }
 
diff --git a/typescript/types/objectDescriptor.h b/typescript/types/objectDescriptor.h
index 0ac489f8c703b994b68d17f9a20c1c8aa0c2e9ca..e43b350ede126e7416caa7d5f9f5d18ec5ac09c0 100644
--- a/typescript/types/objectDescriptor.h
+++ b/typescript/types/objectDescriptor.h
@@ -43,11 +43,11 @@ public:
     void Copy(ArenaAllocator *allocator, ObjectDescriptor *copiedDesc, TypeRelation *relation,
               GlobalTypesHolder *globalTypes);
 
-    std::vector<binder::LocalVariable *> properties {};
-    std::vector<Signature *> callSignatures {};
-    std::vector<Signature *> constructSignatures {};
-    IndexInfo *stringIndexInfo {nullptr};
-    IndexInfo *numberIndexInfo {nullptr};
+    std::vector<binder::LocalVariable *> properties_ {};
+    std::vector<Signature *> call_signatures_ {};
+    std::vector<Signature *> construct_signatures_ {};
+    IndexInfo *string_index_info_ {nullptr};
+    IndexInfo *number_index_info_ {nullptr};
 };
 
 }  // namespace panda::es2panda::checker
diff --git a/typescript/types/objectLiteralType.cpp b/typescript/types/objectLiteralType.cpp
index ccdd18d6f757ceb68d439d67b286c1f46752363d..f19e02a05fe4f3031065770b0881ee4d82bb3699 100644
--- a/typescript/types/objectLiteralType.cpp
+++ b/typescript/types/objectLiteralType.cpp
@@ -30,28 +30,28 @@ void ObjectLiteralType::ToString(std::stringstream &ss) const
 {
     ss << "{ ";
 
-    if (desc_->stringIndexInfo) {
-        desc_->stringIndexInfo->ToString(ss, false);
+    if (desc_->string_index_info_) {
+        desc_->string_index_info_->ToString(ss, false);
         ss << "; ";
     }
 
-    if (desc_->numberIndexInfo) {
-        desc_->numberIndexInfo->ToString(ss, true);
+    if (desc_->number_index_info_) {
+        desc_->number_index_info_->ToString(ss, true);
         ss << "; ";
     }
 
-    for (auto *it : desc_->callSignatures) {
+    for (auto *it : desc_->call_signatures_) {
         it->ToString(ss, nullptr, true);
         ss << "; ";
     }
 
-    for (auto *it : desc_->constructSignatures) {
+    for (auto *it : desc_->construct_signatures_) {
         ss << "new ";
         it->ToString(ss, nullptr, true);
         ss << "; ";
     }
 
-    for (auto *it : desc_->properties) {
+    for (auto *it : desc_->properties_) {
         if (it->HasFlag(binder::VariableFlags::READONLY)) {
             ss << "readonly ";
         }
@@ -72,8 +72,8 @@ void ObjectLiteralType::ToString(std::stringstream &ss) const
 
 TypeFacts ObjectLiteralType::GetTypeFacts() const
 {
-    if (desc_->properties.empty() && desc_->callSignatures.empty() && desc_->constructSignatures.empty() &&
-        !desc_->numberIndexInfo && !desc_->stringIndexInfo) {
+    if (desc_->properties_.empty() && desc_->call_signatures_.empty() && desc_->construct_signatures_.empty() &&
+        !desc_->number_index_info_ && !desc_->string_index_info_) {
         return TypeFacts::EMPTY_OBJECT_FACTS;
     }
 
diff --git a/typescript/types/objectType.cpp b/typescript/types/objectType.cpp
index f70167b2342b622e8f7ae266daaa184ca61c894d..71aae39ca0f6daa84b94659b5d558edc83eccf62 100644
--- a/typescript/types/objectType.cpp
+++ b/typescript/types/objectType.cpp
@@ -24,12 +24,12 @@
 namespace panda::es2panda::checker {
 
 ObjectType::ObjectType(ObjectTypeKind kind)
-    : Type(TypeFlag::OBJECT), kind_(kind), desc_(nullptr), objFlag_(ObjectFlags::CHECK_EXCESS_PROPS)
+    : Type(TypeFlag::OBJECT), kind_(kind), desc_(nullptr), obj_flag_(ObjectFlags::CHECK_EXCESS_PROPS)
 {
 }
 
 ObjectType::ObjectType(ObjectTypeKind kind, ObjectDescriptor *desc)
-    : Type(TypeFlag::OBJECT), kind_(kind), desc_(desc), objFlag_(ObjectFlags::CHECK_EXCESS_PROPS)
+    : Type(TypeFlag::OBJECT), kind_(kind), desc_(desc), obj_flag_(ObjectFlags::CHECK_EXCESS_PROPS)
 {
 }
 
@@ -40,42 +40,42 @@ ObjectType::ObjectTypeKind ObjectType::Kind() const
 
 std::vector<Signature *> &ObjectType::CallSignatures()
 {
-    return desc_->callSignatures;
+    return desc_->call_signatures_;
 }
 
 const std::vector<Signature *> &ObjectType::CallSignatures() const
 {
-    return desc_->callSignatures;
+    return desc_->call_signatures_;
 }
 
 const std::vector<Signature *> &ObjectType::ConstructSignatures() const
 {
-    return desc_->constructSignatures;
+    return desc_->construct_signatures_;
 }
 
 const IndexInfo *ObjectType::StringIndexInfo() const
 {
-    return desc_->stringIndexInfo;
+    return desc_->string_index_info_;
 }
 
 const IndexInfo *ObjectType::NumberIndexInfo() const
 {
-    return desc_->numberIndexInfo;
+    return desc_->number_index_info_;
 }
 
 IndexInfo *ObjectType::StringIndexInfo()
 {
-    return desc_->stringIndexInfo;
+    return desc_->string_index_info_;
 }
 
 IndexInfo *ObjectType::NumberIndexInfo()
 {
-    return desc_->numberIndexInfo;
+    return desc_->number_index_info_;
 }
 
 const std::vector<binder::LocalVariable *> &ObjectType::Properties() const
 {
-    return desc_->properties;
+    return desc_->properties_;
 }
 
 ObjectDescriptor *ObjectType::Desc()
@@ -90,12 +90,12 @@ const ObjectDescriptor *ObjectType::Desc() const
 
 void ObjectType::AddProperty(binder::LocalVariable *prop)
 {
-    desc_->properties.push_back(prop);
+    desc_->properties_.push_back(prop);
 }
 
 binder::LocalVariable *ObjectType::GetProperty(const util::StringView &name) const
 {
-    for (auto *it : desc_->properties) {
+    for (auto *it : desc_->properties_) {
         if (name == it->Name()) {
             return it;
         }
@@ -107,25 +107,25 @@ binder::LocalVariable *ObjectType::GetProperty(const util::StringView &name) con
 void ObjectType::AddSignature(Signature *signature, bool isCall)
 {
     if (isCall) {
-        desc_->callSignatures.push_back(signature);
+        desc_->call_signatures_.push_back(signature);
     } else {
-        desc_->constructSignatures.push_back(signature);
+        desc_->construct_signatures_.push_back(signature);
     }
 }
 
 void ObjectType::AddObjectFlag(ObjectFlags flag)
 {
-    objFlag_ |= flag;
+    obj_flag_ |= flag;
 }
 
 void ObjectType::RemoveObjectFlag(ObjectFlags flag)
 {
-    objFlag_ &= ~flag;
+    obj_flag_ &= ~flag;
 }
 
 bool ObjectType::HasObjectFlag(ObjectFlags flag) const
 {
-    return (objFlag_ & flag) != 0;
+    return (obj_flag_ & flag) != 0;
 }
 
 bool ObjectType::EachSignatureRelatedToSomeSignature(TypeRelation *relation,
@@ -163,18 +163,18 @@ void ObjectType::Identical(TypeRelation *relation, const Type *other) const
 
     const ObjectType *otherObj = other->AsObjectType();
 
-    if (desc_->properties.size() != otherObj->Properties().size() ||
+    if (desc_->properties_.size() != otherObj->Properties().size() ||
         CallSignatures().size() != otherObj->CallSignatures().size() ||
         ConstructSignatures().size() != otherObj->ConstructSignatures().size() ||
-        (desc_->numberIndexInfo && !otherObj->NumberIndexInfo()) ||
-        (!desc_->numberIndexInfo && otherObj->NumberIndexInfo()) ||
-        (desc_->stringIndexInfo && !otherObj->StringIndexInfo()) ||
-        (!desc_->stringIndexInfo && otherObj->StringIndexInfo())) {
+        (desc_->number_index_info_ && !otherObj->NumberIndexInfo()) ||
+        (!desc_->number_index_info_ && otherObj->NumberIndexInfo()) ||
+        (desc_->string_index_info_ && !otherObj->StringIndexInfo()) ||
+        (!desc_->string_index_info_ && otherObj->StringIndexInfo())) {
         relation->Result(false);
         return;
     }
 
-    for (auto *it : desc_->properties) {
+    for (auto *it : desc_->properties_) {
         binder::LocalVariable *found = otherObj->Desc()->FindProperty(it->Name());
         if (!found) {
             relation->Result(false);
@@ -203,15 +203,15 @@ void ObjectType::Identical(TypeRelation *relation, const Type *other) const
         return;
     }
 
-    if (desc_->numberIndexInfo) {
-        relation->IsIdenticalTo(desc_->numberIndexInfo, otherObj->NumberIndexInfo());
+    if (desc_->number_index_info_) {
+        relation->IsIdenticalTo(desc_->number_index_info_, otherObj->NumberIndexInfo());
         if (!relation->IsTrue()) {
             return;
         }
     }
 
-    if (desc_->stringIndexInfo) {
-        relation->IsIdenticalTo(desc_->stringIndexInfo, otherObj->StringIndexInfo());
+    if (desc_->string_index_info_) {
+        relation->IsIdenticalTo(desc_->string_index_info_, otherObj->StringIndexInfo());
         if (!relation->IsTrue()) {
             return;
         }
@@ -230,9 +230,9 @@ void ObjectType::AssignProperties(TypeRelation *relation, const ObjectType *sour
         numberInfo = this->AsInterfaceType()->FindIndexInfo(true);
         stringInfo = this->AsInterfaceType()->FindIndexInfo(false);
     } else {
-        targetProperties = desc_->properties;
-        numberInfo = desc_->numberIndexInfo;
-        stringInfo = desc_->stringIndexInfo;
+        targetProperties = desc_->properties_;
+        numberInfo = desc_->number_index_info_;
+        stringInfo = desc_->string_index_info_;
     }
 
     for (auto *it : targetProperties) {
diff --git a/typescript/types/objectType.h b/typescript/types/objectType.h
index f8ab9c9aa75964f0bdc0741454a1f19c36240309..a627d7a31d2b9bd37793c8955fecddc2f9bf6e88 100644
--- a/typescript/types/objectType.h
+++ b/typescript/types/objectType.h
@@ -113,7 +113,7 @@ public:
 protected:
     ObjectTypeKind kind_;
     ObjectDescriptor *desc_;
-    ObjectFlags objFlag_;
+    ObjectFlags obj_flag_;
 };
 
 DEFINE_BITOPS(ObjectType::ObjectFlags)
diff --git a/typescript/types/signature.cpp b/typescript/types/signature.cpp
index 2d0568c9bbcdcb21f16b0c5da5956c157527a46d..e766a84077a295c5fff17b87edeffcd722d8b36e 100644
--- a/typescript/types/signature.cpp
+++ b/typescript/types/signature.cpp
@@ -21,71 +21,71 @@ namespace panda::es2panda::checker {
 
 SignatureInfo::SignatureInfo(const SignatureInfo *other, ArenaAllocator *allocator)
 {
-    for (auto *it : other->funcParams) {
-        funcParams.push_back(it->Copy(allocator, it->Declaration()));
+    for (auto *it : other->func_params_) {
+        func_params_.push_back(it->Copy(allocator, it->Declaration()));
     }
 
-    minArgCount = other->minArgCount;
+    min_arg_count_ = other->min_arg_count_;
 
-    if (other->restVar) {
-        restVar = other->restVar->Copy(allocator, other->restVar->Declaration());
+    if (other->rest_var_) {
+        rest_var_ = other->rest_var_->Copy(allocator, other->rest_var_->Declaration());
     }
 }
 
 Signature::Signature(SignatureInfo *signatureInfo, Type *returnType)
-    : signatureInfo_(signatureInfo), returnType_(returnType)
+    : signature_info_(signatureInfo), return_type_(returnType)
 {
 }
 
 const SignatureInfo *Signature::Info() const
 {
-    return signatureInfo_;
+    return signature_info_;
 }
 
 const std::vector<binder::LocalVariable *> &Signature::Params() const
 {
-    return signatureInfo_->funcParams;
+    return signature_info_->func_params_;
 }
 
 const Type *Signature::ReturnType() const
 {
-    return returnType_;
+    return return_type_;
 }
 
 Type *Signature::ReturnType()
 {
-    return returnType_;
+    return return_type_;
 }
 
 uint32_t Signature::MinArgCount() const
 {
-    return signatureInfo_->minArgCount;
+    return signature_info_->min_arg_count_;
 }
 
 uint32_t Signature::OptionalArgCount() const
 {
-    return signatureInfo_->funcParams.size() - signatureInfo_->minArgCount;
+    return signature_info_->func_params_.size() - signature_info_->min_arg_count_;
 }
 
 void Signature::SetReturnType(Type *type)
 {
-    returnType_ = type;
+    return_type_ = type;
 }
 
 const binder::LocalVariable *Signature::RestVar() const
 {
-    return signatureInfo_->restVar;
+    return signature_info_->rest_var_;
 }
 
 Signature *Signature::Copy(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
 {
-    SignatureInfo *copiedInfo = allocator->New<checker::SignatureInfo>(signatureInfo_, allocator);
+    SignatureInfo *copiedInfo = allocator->New<checker::SignatureInfo>(signature_info_, allocator);
 
-    for (auto *it : copiedInfo->funcParams) {
+    for (auto *it : copiedInfo->func_params_) {
         it->SetTsType(it->TsType()->Instantiate(allocator, relation, globalTypes));
     }
 
-    Type *copiedReturnType = returnType_->Instantiate(allocator, relation, globalTypes);
+    Type *copiedReturnType = return_type_->Instantiate(allocator, relation, globalTypes);
 
     return allocator->New<Signature>(copiedInfo, copiedReturnType);
 }
@@ -94,7 +94,7 @@ void Signature::ToString(std::stringstream &ss, const binder::Variable *variable
 {
     ss << "(";
 
-    for (auto it = signatureInfo_->funcParams.begin(); it != signatureInfo_->funcParams.end(); it++) {
+    for (auto it = signature_info_->func_params_.begin(); it != signature_info_->func_params_.end(); it++) {
         ss << (*it)->Name();
 
         if ((*it)->HasFlag(binder::VariableFlags::OPTIONAL)) {
@@ -105,20 +105,20 @@ void Signature::ToString(std::stringstream &ss, const binder::Variable *variable
 
         (*it)->TsType()->ToString(ss);
 
-        if (std::next(it) != signatureInfo_->funcParams.end()) {
+        if (std::next(it) != signature_info_->func_params_.end()) {
             ss << ", ";
         }
     }
 
-    if (signatureInfo_->restVar) {
-        if (!signatureInfo_->funcParams.empty()) {
+    if (signature_info_->rest_var_) {
+        if (!signature_info_->func_params_.empty()) {
             ss << ", ";
         }
 
         ss << "...";
-        ss << signatureInfo_->restVar->Name();
+        ss << signature_info_->rest_var_->Name();
         ss << ": ";
-        signatureInfo_->restVar->TsType()->ToString(ss);
+        signature_info_->rest_var_->TsType()->ToString(ss);
         ss << "[]";
     }
 
@@ -130,30 +130,31 @@ void Signature::ToString(std::stringstream &ss, const binder::Variable *variable
         ss << " => ";
     }
 
-    returnType_->ToString(ss);
+    return_type_->ToString(ss);
 }
 
 void Signature::Identical(TypeRelation *relation, const Signature *other) const
 {
-    if (signatureInfo_->minArgCount != other->MinArgCount() ||
-        signatureInfo_->funcParams.size() != other->Params().size()) {
+    if (signature_info_->min_arg_count_ != other->MinArgCount() ||
+        signature_info_->func_params_.size() != other->Params().size()) {
         relation->Result(false);
         return;
     }
 
-    relation->IsIdenticalTo(returnType_, other->ReturnType());
+    relation->IsIdenticalTo(return_type_, other->ReturnType());
 
     if (relation->IsTrue()) {
-        for (uint64_t i = 0; i < signatureInfo_->funcParams.size(); i++) {
-            relation->IsIdenticalTo(signatureInfo_->funcParams[i]->TsType(), other->Params()[i]->TsType());
+        for (uint64_t i = 0; i < signature_info_->func_params_.size(); i++) {
+            relation->IsIdenticalTo(signature_info_->func_params_[i]->TsType(), other->Params()[i]->TsType());
             if (!relation->IsTrue()) {
                 return;
             }
         }
 
-        if (signatureInfo_->restVar && other->RestVar()) {
-            relation->IsIdenticalTo(signatureInfo_->restVar->TsType(), other->RestVar()->TsType());
-        } else if ((signatureInfo_->restVar && !other->RestVar()) || (!signatureInfo_->restVar && other->RestVar())) {
+        if (signature_info_->rest_var_ && other->RestVar()) {
+            relation->IsIdenticalTo(signature_info_->rest_var_->TsType(), other->RestVar()->TsType());
+        } else if ((signature_info_->rest_var_ && !other->RestVar()) ||
+                   (!signature_info_->rest_var_ && other->RestVar())) {
             relation->Result(false);
         }
     }
@@ -161,19 +162,19 @@ void Signature::Identical(TypeRelation *relation, const Signature *other) const
 
 void Signature::AssignmentTarget(TypeRelation *relation, const Signature *source) const
 {
-    if (!signatureInfo_->restVar &&
-        (source->Params().size() - source->OptionalArgCount()) > signatureInfo_->funcParams.size()) {
+    if (!signature_info_->rest_var_ &&
+        (source->Params().size() - source->OptionalArgCount()) > signature_info_->func_params_.size()) {
         relation->Result(false);
         return;
     }
 
     for (size_t i = 0; i < source->Params().size(); i++) {
-        if (!signatureInfo_->restVar && i >= Params().size()) {
+        if (!signature_info_->rest_var_ && i >= Params().size()) {
             break;
         }
 
-        if (signatureInfo_->restVar) {
-            relation->IsAssignableTo(source->Params()[i]->TsType(), signatureInfo_->restVar->TsType());
+        if (signature_info_->rest_var_) {
+            relation->IsAssignableTo(source->Params()[i]->TsType(), signature_info_->rest_var_->TsType());
 
             if (!relation->IsTrue()) {
                 return;
@@ -191,8 +192,8 @@ void Signature::AssignmentTarget(TypeRelation *relation, const Signature *source
 
     relation->IsAssignableTo(source->ReturnType(), ReturnType());
 
-    if (relation->IsTrue() && signatureInfo_->restVar && source->RestVar()) {
-        relation->IsAssignableTo(source->RestVar()->TsType(), signatureInfo_->restVar->TsType());
+    if (relation->IsTrue() && signature_info_->rest_var_ && source->RestVar()) {
+        relation->IsAssignableTo(source->RestVar()->TsType(), signature_info_->rest_var_->TsType());
     }
 }
 
diff --git a/typescript/types/signature.h b/typescript/types/signature.h
index 5943e59311880519ff2dedc57c9e2a525c0d4429..6cfacde9b189ad23919f6cd5c1dfc9b12db464d3 100644
--- a/typescript/types/signature.h
+++ b/typescript/types/signature.h
@@ -32,9 +32,9 @@ public:
     NO_MOVE_SEMANTIC(SignatureInfo);
     ~SignatureInfo() = default;
 
-    uint32_t minArgCount {};
-    binder::LocalVariable *restVar {};
-    std::vector<binder::LocalVariable *> funcParams {};
+    uint32_t min_arg_count_ {};
+    binder::LocalVariable *rest_var_ {};
+    std::vector<binder::LocalVariable *> func_params_ {};
 };
 
 class Signature {
@@ -59,8 +59,8 @@ public:
     void AssignmentTarget(TypeRelation *relation, const Signature *source) const;
 
 private:
-    SignatureInfo *signatureInfo_;
-    Type *returnType_;
+    SignatureInfo *signature_info_;
+    Type *return_type_;
 };
 
 }  // namespace panda::es2panda::checker
diff --git a/typescript/types/tupleType.cpp b/typescript/types/tupleType.cpp
index d0a8597ee4e8f40aeaa3c44f4ca2817a6a0d7fcf..1256af7379e2c18375b87e2347b6cd6ce4a77120 100644
--- a/typescript/types/tupleType.cpp
+++ b/typescript/types/tupleType.cpp
@@ -19,15 +19,15 @@
 
 namespace panda::es2panda::checker {
 
-TupleTypeIterator::TupleTypeIterator(TupleType *tuple) : tupleType_(tuple) {}
+TupleTypeIterator::TupleTypeIterator(TupleType *tuple) : tuple_type_(tuple) {}
 
 Type *TupleTypeIterator::Next()
 {
-    if (iter_ >= tupleType_->Properties().size()) {
+    if (iter_ >= tuple_type_->Properties().size()) {
         return nullptr;
     }
 
-    Type *returnType = tupleType_->Properties()[iter_]->TsType();
+    Type *returnType = tuple_type_->Properties()[iter_]->TsType();
 
     iter_++;
 
@@ -36,11 +36,11 @@ Type *TupleTypeIterator::Next()
 
 Type *TupleTypeIterator::Current()
 {
-    if (iter_ >= tupleType_->Properties().size()) {
+    if (iter_ >= tuple_type_->Properties().size()) {
         return nullptr;
     }
 
-    return tupleType_->Properties()[iter_]->TsType();
+    return tuple_type_->Properties()[iter_]->TsType();
 }
 
 uint32_t TupleTypeIterator::Iter() const
@@ -51,10 +51,10 @@ uint32_t TupleTypeIterator::Iter() const
 TupleType::TupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
                      uint32_t minLength, uint32_t fixedLength, bool readonly)
     : ObjectType(ObjectType::ObjectTypeKind::TUPLE, desc),
-      elementFlags_(std::move(elementFlags)),
-      combinedFlags_(combinedFlags),
-      minLength_(minLength),
-      fixedLength_(fixedLength),
+      element_flags_(std::move(elementFlags)),
+      combined_flags_(combinedFlags),
+      min_length_(minLength),
+      fixed_length_(fixedLength),
       readonly_(readonly)
 {
     if (readonly_) {
@@ -69,11 +69,11 @@ TupleType::TupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags
 TupleType::TupleType(ObjectDescriptor *desc, TupleElementFlagPool &&elementFlags, ElementFlags combinedFlags,
                      uint32_t minLength, uint32_t fixedLength, bool readonly, NamedTupleMemberPool &&namedMembers)
     : ObjectType(ObjectType::ObjectTypeKind::TUPLE, desc),
-      elementFlags_(std::move(elementFlags)),
-      combinedFlags_(combinedFlags),
-      minLength_(minLength),
-      fixedLength_(fixedLength),
-      namedMembers_(std::move(namedMembers)),
+      element_flags_(std::move(elementFlags)),
+      combined_flags_(combinedFlags),
+      min_length_(minLength),
+      fixed_length_(fixedLength),
+      named_members_(std::move(namedMembers)),
       readonly_(readonly)
 {
     if (readonly_) {
@@ -94,23 +94,23 @@ TupleType::~TupleType()
 
 ElementFlags TupleType::CombinedFlags() const
 {
-    return combinedFlags_;
+    return combined_flags_;
 }
 
 uint32_t TupleType::MinLength() const
 {
-    return minLength_;
+    return min_length_;
 }
 
 uint32_t TupleType::FixedLength() const
 {
-    return fixedLength_;
+    return fixed_length_;
 }
 
 ElementFlags TupleType::GetElementFlag(const util::StringView &index) const
 {
-    auto res = elementFlags_.find(index);
-    if (res != elementFlags_.end()) {
+    auto res = element_flags_.find(index);
+    if (res != element_flags_.end()) {
         return res->second;
     }
     return ElementFlags::NO_OPTS;
@@ -118,7 +118,7 @@ ElementFlags TupleType::GetElementFlag(const util::StringView &index) const
 
 bool TupleType::HasCombinedFlag(ElementFlags combinedFlag) const
 {
-    return (combinedFlags_ & combinedFlag) != 0;
+    return (combined_flags_ & combinedFlag) != 0;
 }
 
 bool TupleType::IsReadOnly() const
@@ -138,12 +138,12 @@ const TupleTypeIterator *TupleType::Iterator() const
 
 const NamedTupleMemberPool &TupleType::NamedMembers() const
 {
-    return namedMembers_;
+    return named_members_;
 }
 
 const util::StringView &TupleType::FindNamedMemberName(binder::LocalVariable *member) const
 {
-    auto res = namedMembers_.find(member);
+    auto res = named_members_.find(member);
     return res->second;
 }
 
@@ -154,19 +154,19 @@ void TupleType::ToString(std::stringstream &ss) const
     }
     ss << "[";
 
-    if (namedMembers_.empty()) {
-        for (auto it = desc_->properties.begin(); it != desc_->properties.end(); it++) {
+    if (named_members_.empty()) {
+        for (auto it = desc_->properties_.begin(); it != desc_->properties_.end(); it++) {
             (*it)->TsType()->ToString(ss);
             if ((*it)->HasFlag(binder::VariableFlags::OPTIONAL)) {
                 ss << "?";
             }
 
-            if (std::next(it) != desc_->properties.end()) {
+            if (std::next(it) != desc_->properties_.end()) {
                 ss << ", ";
             }
         }
     } else {
-        for (auto it = desc_->properties.begin(); it != desc_->properties.end(); it++) {
+        for (auto it = desc_->properties_.begin(); it != desc_->properties_.end(); it++) {
             const util::StringView &memberName = FindNamedMemberName(*it);
             ss << memberName;
 
@@ -176,7 +176,7 @@ void TupleType::ToString(std::stringstream &ss) const
 
             ss << ": ";
             (*it)->TsType()->ToString(ss);
-            if (std::next(it) != desc_->properties.end()) {
+            if (std::next(it) != desc_->properties_.end()) {
                 ss << ", ";
             }
         }
@@ -189,10 +189,10 @@ void TupleType::Identical(TypeRelation *relation, const Type *other) const
 {
     if (other->IsObjectType() && other->AsObjectType()->IsTupleType()) {
         const TupleType *otherTuple = other->AsObjectType()->AsTupleType();
-        if (kind_ == otherTuple->Kind() && desc_->properties.size() == otherTuple->Properties().size()) {
+        if (kind_ == otherTuple->Kind() && desc_->properties_.size() == otherTuple->Properties().size()) {
             const auto &otherProperties = otherTuple->Properties();
-            for (size_t i = 0; i < desc_->properties.size(); i++) {
-                binder::LocalVariable *targetProp = desc_->properties[i];
+            for (size_t i = 0; i < desc_->properties_.size(); i++) {
+                binder::LocalVariable *targetProp = desc_->properties_[i];
                 binder::LocalVariable *sourceProp = otherProperties[i];
 
                 if (targetProp->Flags() != sourceProp->Flags()) {
@@ -227,8 +227,8 @@ void TupleType::AssignmentTarget(TypeRelation *relation, const Type *source) con
     relation->Result(true);
 
     const auto &sourceProperties = sourceTuple->Properties();
-    for (size_t i = 0; i < desc_->properties.size(); i++) {
-        auto *targetProp = desc_->properties[i];
+    for (size_t i = 0; i < desc_->properties_.size(); i++) {
+        auto *targetProp = desc_->properties_[i];
 
         if (i < sourceProperties.size()) {
             if (!targetProp->HasFlag(binder::VariableFlags::OPTIONAL) &&
@@ -259,7 +259,7 @@ void TupleType::AssignmentTarget(TypeRelation *relation, const Type *source) con
 
 TypeFacts TupleType::GetTypeFacts() const
 {
-    if (desc_->properties.empty()) {
+    if (desc_->properties_.empty()) {
         return TypeFacts::EMPTY_OBJECT_FACTS;
     }
 
@@ -272,11 +272,11 @@ Type *TupleType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation,
 
     desc_->Copy(allocator, copiedDesc, relation, globalTypes);
 
-    NamedTupleMemberPool copiedNamedMemberPool = namedMembers_;
-    TupleElementFlagPool copiedElementFlagPool = elementFlags_;
+    NamedTupleMemberPool copiedNamedMemberPool = named_members_;
+    TupleElementFlagPool copiedElementFlagPool = element_flags_;
 
-    return allocator->New<TupleType>(copiedDesc, std::move(copiedElementFlagPool), combinedFlags_, minLength_,
-                                     fixedLength_, readonly_, std::move(copiedNamedMemberPool));
+    return allocator->New<TupleType>(copiedDesc, std::move(copiedElementFlagPool), combined_flags_, min_length_,
+                                     fixed_length_, readonly_, std::move(copiedNamedMemberPool));
 }
 
 }  // namespace panda::es2panda::checker
diff --git a/typescript/types/tupleType.h b/typescript/types/tupleType.h
index e64a7009f5cb401e5a4e3f789eabf4c056f2243b..15dd8c7c89a5e51593c390081ae79485700ae0fc 100644
--- a/typescript/types/tupleType.h
+++ b/typescript/types/tupleType.h
@@ -35,7 +35,7 @@ public:
     uint32_t Iter() const;
 
 private:
-    TupleType *tupleType_;
+    TupleType *tuple_type_;
     uint32_t iter_ {0};
 };
 
@@ -72,11 +72,11 @@ public:
     Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) override;
 
 private:
-    TupleElementFlagPool elementFlags_ {};
-    ElementFlags combinedFlags_ {};
-    uint32_t minLength_ {};
-    uint32_t fixedLength_ {};
-    NamedTupleMemberPool namedMembers_ {};
+    TupleElementFlagPool element_flags_ {};
+    ElementFlags combined_flags_ {};
+    uint32_t min_length_ {};
+    uint32_t fixed_length_ {};
+    NamedTupleMemberPool named_members_ {};
     bool readonly_ {};
     TupleTypeIterator *iterator_ {nullptr};
 };
diff --git a/typescript/types/type.cpp b/typescript/types/type.cpp
index 38c732ac7a4b971d98c169c7a498df66d6b1f0ae..513d3b94a8faffdeddd547fb2826de98e8fd0bfb 100644
--- a/typescript/types/type.cpp
+++ b/typescript/types/type.cpp
@@ -21,7 +21,7 @@
 
 namespace panda::es2panda::checker {
 
-Type::Type(TypeFlag flag) : typeFlags_(flag)
+Type::Type(TypeFlag flag) : type_flags_(flag)
 {
     static uint64_t typeId = 0;
     id_ = ++typeId;
@@ -29,22 +29,22 @@ Type::Type(TypeFlag flag) : typeFlags_(flag)
 
 TypeFlag Type::TypeFlags() const
 {
-    return typeFlags_;
+    return type_flags_;
 }
 
 bool Type::HasTypeFlag(TypeFlag typeFlag) const
 {
-    return (typeFlags_ & typeFlag) != 0;
+    return (type_flags_ & typeFlag) != 0;
 }
 
 void Type::AddTypeFlag(TypeFlag typeFlag)
 {
-    typeFlags_ |= typeFlag;
+    type_flags_ |= typeFlag;
 }
 
 void Type::RemoveTypeFlag(TypeFlag typeFlag)
 {
-    typeFlags_ &= ~typeFlag;
+    type_flags_ &= ~typeFlag;
 }
 
 uint64_t Type::Id() const
@@ -74,7 +74,7 @@ const binder::Variable *Type::Variable() const
 
 void Type::Identical(TypeRelation *relation, const Type *other) const
 {
-    relation->Result(typeFlags_ == other->TypeFlags());
+    relation->Result(type_flags_ == other->TypeFlags());
 }
 
 bool Type::AssignmentSource([[maybe_unused]] TypeRelation *relation, [[maybe_unused]] const Type *target) const
diff --git a/typescript/types/type.h b/typescript/types/type.h
index 7c5f311646903e06fda4a87648d2851c263db4b8..ee656c13ffc6191527d2d44fda25291fa4ad46a0 100644
--- a/typescript/types/type.h
+++ b/typescript/types/type.h
@@ -88,7 +88,7 @@ public:
     virtual Type *Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) = 0;
 
 protected:
-    TypeFlag typeFlags_;
+    TypeFlag type_flags_;
     binder::Variable *variable_ {nullptr};  // Variable associated with the type if any
     uint64_t id_;
 };
diff --git a/typescript/types/typeRelation.cpp b/typescript/types/typeRelation.cpp
index 7bee1301e243d1cd6840946ffdf474a510d78a2e..a9540f9c55279923cbf68bada6982206b19f533c 100644
--- a/typescript/types/typeRelation.cpp
+++ b/typescript/types/typeRelation.cpp
@@ -46,16 +46,16 @@ RelationResult TypeRelation::CacheLookup(const Type *source, const Type *target,
     }
 
     RelationKey relationKey {source->Id(), target->Id()};
-    auto res = holder.cached.find(relationKey);
-    if (res == holder.cached.end()) {
+    auto res = holder.cached_.find(relationKey);
+    if (res == holder.cached_.end()) {
         return RelationResult::CACHE_MISS;
     }
 
-    if (res->second.type >= type && res->second.result == RelationResult::TRUE) {
+    if (res->second.type_ >= type && res->second.result_ == RelationResult::TRUE) {
         return RelationResult::TRUE;
     }
 
-    if (res->second.type <= type && res->second.result == RelationResult::FALSE) {
+    if (res->second.type_ <= type && res->second.result_ == RelationResult::FALSE) {
         return RelationResult::FALSE;
     }
 
@@ -73,7 +73,7 @@ bool TypeRelation::IsIdenticalTo(const Type *source, const Type *target)
     if (result_ == RelationResult::CACHE_MISS) {
         result_ = RelationResult::FALSE;
         target->Identical(this, source);
-        checker_->IdenticalResults().cached.insert({{source->Id(), target->Id()}, {result_, RelationType::IDENTICAL}});
+        checker_->IdenticalResults().cached_.insert({{source->Id(), target->Id()}, {result_, RelationType::IDENTICAL}});
     }
 
     return result_ == RelationResult::TRUE;
@@ -119,7 +119,7 @@ bool TypeRelation::IsAssignableTo(const Type *source, const Type *target)
             target->AssignmentTarget(this, source);
         }
 
-        checker_->AssignableResults().cached.insert(
+        checker_->AssignableResults().cached_.insert(
             {{source->Id(), target->Id()}, {result_, RelationType::ASSIGNABLE}});
     }
 
@@ -137,7 +137,7 @@ bool TypeRelation::IsComparableTo(const Type *source, const Type *target)
 
         result_ = RelationResult::FALSE;
         target->Compare(this, source);
-        checker_->ComparableResults().cached.insert(
+        checker_->ComparableResults().cached_.insert(
             {{source->Id(), target->Id()}, {result_, RelationType::COMPARABLE}});
     }
 
diff --git a/typescript/types/typeRelation.h b/typescript/types/typeRelation.h
index 9591841a371c0b4afd0c495945fff2bd27bac1e1..1269ffd263fc5e1328a7586401a72bfcfa6e5653 100644
--- a/typescript/types/typeRelation.h
+++ b/typescript/types/typeRelation.h
@@ -37,15 +37,15 @@ enum class RelationType { COMPARABLE, ASSIGNABLE, IDENTICAL };
 
 class RelationKey {
 public:
-    uint64_t sourceId;
-    uint64_t targetId;
+    uint64_t source_id_;
+    uint64_t target_id_;
 };
 
 class RelationKeyHasher {
 public:
     size_t operator()(const RelationKey &key) const noexcept
     {
-        return static_cast<size_t>(key.sourceId ^ key.targetId);
+        return static_cast<size_t>(key.source_id_ ^ key.target_id_);
     }
 };
 
@@ -53,22 +53,22 @@ class RelationKeyComparator {
 public:
     bool operator()(const RelationKey &lhs, const RelationKey &rhs) const
     {
-        return lhs.sourceId == rhs.sourceId && lhs.targetId == rhs.targetId;
+        return lhs.source_id_ == rhs.source_id_ && lhs.target_id_ == rhs.target_id_;
     }
 };
 
 class RealtionEntry {
 public:
-    RelationResult result;
-    RelationType type;
+    RelationResult result_;
+    RelationType type_;
 };
 
 using RelationMap = std::unordered_map<RelationKey, RealtionEntry, RelationKeyHasher, RelationKeyComparator>;
 
 class RelationHolder {
 public:
-    RelationMap cached;
-    RelationType type {};
+    RelationMap cached_;
+    RelationType type_ {};
 };
 
 class AsSrc {
diff --git a/typescript/types/unionType.cpp b/typescript/types/unionType.cpp
index 54211b592e8b72c5426af90bb21e1a6c981dd30f..106b70e7a4480e56e2f5e823bbf7b2cd3085b331 100644
--- a/typescript/types/unionType.cpp
+++ b/typescript/types/unionType.cpp
@@ -21,9 +21,9 @@
 namespace panda::es2panda::checker {
 
 UnionType::UnionType(std::vector<Type *> &&constituentTypes)
-    : Type(TypeFlag::UNION), constituentTypes_(std::move(constituentTypes))
+    : Type(TypeFlag::UNION), constituent_types_(std::move(constituentTypes))
 {
-    for (auto *it : constituentTypes_) {
+    for (auto *it : constituent_types_) {
         AddConstituentFlag(it->TypeFlags());
     }
 }
@@ -31,19 +31,19 @@ UnionType::UnionType(std::vector<Type *> &&constituentTypes)
 UnionType::UnionType(std::initializer_list<Type *> types) : Type(TypeFlag::UNION)
 {
     for (auto *it : types) {
-        constituentTypes_.push_back(it);
+        constituent_types_.push_back(it);
         AddConstituentFlag(it->TypeFlags());
     }
 }
 
 const std::vector<Type *> &UnionType::ConstituentTypes() const
 {
-    return constituentTypes_;
+    return constituent_types_;
 }
 
 std::vector<Type *> &UnionType::ConstituentTypes()
 {
-    return constituentTypes_;
+    return constituent_types_;
 }
 
 void UnionType::AddConstituentType(Type *type, TypeRelation *relation)
@@ -55,36 +55,36 @@ void UnionType::AddConstituentType(Type *type, TypeRelation *relation)
         return;
     }
 
-    for (auto *it : constituentTypes_) {
+    for (auto *it : constituent_types_) {
         if (relation->IsIdenticalTo(it, type)) {
             return;
         }
     }
 
     AddConstituentFlag(type->TypeFlags());
-    constituentTypes_.push_back(type);
+    constituent_types_.push_back(type);
 }
 
 void UnionType::AddConstituentFlag(TypeFlag flag)
 {
-    constituentFlags_ |= flag;
+    constituent_flags_ |= flag;
 }
 
 void UnionType::RemoveConstituentFlag(TypeFlag flag)
 {
-    constituentFlags_ &= ~flag;
+    constituent_flags_ &= ~flag;
 }
 
 bool UnionType::HasConstituentFlag(TypeFlag flag) const
 {
-    return (constituentFlags_ & flag) != 0;
+    return (constituent_flags_ & flag) != 0;
 }
 
 void UnionType::ToString(std::stringstream &ss) const
 {
-    for (auto it = constituentTypes_.begin(); it != constituentTypes_.end(); it++) {
+    for (auto it = constituent_types_.begin(); it != constituent_types_.end(); it++) {
         (*it)->ToString(ss);
-        if (std::next(it) != constituentTypes_.end()) {
+        if (std::next(it) != constituent_types_.end()) {
             ss << " | ";
         }
     }
@@ -92,13 +92,13 @@ void UnionType::ToString(std::stringstream &ss) const
 
 bool UnionType::EachTypeRelatedToSomeType(TypeRelation *relation, const UnionType *source, const UnionType *target)
 {
-    return std::all_of(source->constituentTypes_.begin(), source->constituentTypes_.end(),
+    return std::all_of(source->constituent_types_.begin(), source->constituent_types_.end(),
                        [relation, target](const auto *s) { return TypeRelatedToSomeType(relation, s, target); });
 }
 
 bool UnionType::TypeRelatedToSomeType(TypeRelation *relation, const Type *source, const UnionType *target)
 {
-    return std::any_of(target->constituentTypes_.begin(), target->constituentTypes_.end(),
+    return std::any_of(target->constituent_types_.begin(), target->constituent_types_.end(),
                        [relation, source](const auto *t) { return relation->IsIdenticalTo(source, t); });
 }
 
@@ -117,7 +117,7 @@ void UnionType::Identical(TypeRelation *relation, const Type *other) const
 
 bool UnionType::AssignmentSource(TypeRelation *relation, const Type *target) const
 {
-    for (auto *it : constituentTypes_) {
+    for (auto *it : constituent_types_) {
         if (!relation->IsAssignableTo(it, target)) {
             return false;
         }
@@ -129,7 +129,7 @@ bool UnionType::AssignmentSource(TypeRelation *relation, const Type *target) con
 
 void UnionType::AssignmentTarget(TypeRelation *relation, const Type *source) const
 {
-    for (auto *it : constituentTypes_) {
+    for (auto *it : constituent_types_) {
         if (relation->IsAssignableTo(source, it)) {
             return;
         }
@@ -140,7 +140,7 @@ TypeFacts UnionType::GetTypeFacts() const
 {
     TypeFacts facts = TypeFacts::NONE;
 
-    for (auto *it : constituentTypes_) {
+    for (auto *it : constituent_types_) {
         facts |= it->GetTypeFacts();
     }
 
@@ -231,9 +231,9 @@ void UnionType::RemoveRedundantLiteralTypesFromUnion(UnionType *type)
 
 Type *UnionType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes)
 {
-    std::vector<Type *> copiedConstituents(constituentTypes_.size());
+    std::vector<Type *> copiedConstituents(constituent_types_.size());
 
-    for (auto *it : constituentTypes_) {
+    for (auto *it : constituent_types_) {
         copiedConstituents.push_back(it->Instantiate(allocator, relation, globalTypes));
     }
 
diff --git a/typescript/types/unionType.h b/typescript/types/unionType.h
index 64aa72674bcd49e1d422626a6fb82450a0eb9b47..e61c94c974623be9327b8bae98faac6d28585fac 100644
--- a/typescript/types/unionType.h
+++ b/typescript/types/unionType.h
@@ -49,8 +49,8 @@ private:
     static bool EachTypeRelatedToSomeType(TypeRelation *relation, const UnionType *source, const UnionType *target);
     static bool TypeRelatedToSomeType(TypeRelation *relation, const Type *source, const UnionType *target);
 
-    std::vector<Type *> constituentTypes_;
-    TypeFlag constituentFlags_ {TypeFlag::NONE};
+    std::vector<Type *> constituent_types_;
+    TypeFlag constituent_flags_ {TypeFlag::NONE};
 };
 
 }  // namespace panda::es2panda::checker
diff --git a/util/bitset.cpp b/util/bitset.cpp
index fca9a34d5352110354c68d221713e44bd09caede..b3dde4174198b78337f0031206fbc23c0d8a0ffc 100644
--- a/util/bitset.cpp
+++ b/util/bitset.cpp
@@ -36,7 +36,7 @@ BitSet::~BitSet()
 
 size_t BitSet::DataSize() const noexcept
 {
-    return (size_ >> shiftOffset) + 1;
+    return (size_ >> SHIFT_OFFSET) + 1;
 }
 
 void BitSet::Clear(bool value) noexcept
@@ -52,8 +52,8 @@ void BitSet::Set(size_t pos) noexcept
 void BitSet::Set(size_t pos, bool value) noexcept
 {
     ASSERT(pos < size_);
-    size_t idx = pos >> shiftOffset;
-    size_t slot = pos & shiftMask;
+    size_t idx = pos >> SHIFT_OFFSET;
+    size_t slot = pos & SHIFT_MASK;
 
     if (value) {
         data_[idx] |= 1U << slot;
@@ -65,8 +65,8 @@ void BitSet::Set(size_t pos, bool value) noexcept
 bool BitSet::Test(size_t pos) const noexcept
 {
     ASSERT(pos < size_);
-    size_t idx = pos >> shiftOffset;
-    size_t slot = pos & shiftMask;
+    size_t idx = pos >> SHIFT_OFFSET;
+    size_t slot = pos & SHIFT_MASK;
 
     return (data_[idx] & (1U << slot)) != 0;
 }
diff --git a/util/bitset.h b/util/bitset.h
index ad621e04c83e4fcb9bf56121583b91ece301e17d..20c899d53262a03471a2cb0860ffc320890e4937 100644
--- a/util/bitset.h
+++ b/util/bitset.h
@@ -36,8 +36,8 @@ public:
     bool Test(size_t pos) const noexcept;
 
 private:
-    static const size_t shiftOffset = 3;
-    static const size_t shiftMask = (1U << shiftOffset) - 1;
+    static const size_t SHIFT_OFFSET = 3;
+    static const size_t SHIFT_MASK = (1U << SHIFT_OFFSET) - 1;
     size_t DataSize() const noexcept;
 
     uint8_t *data_;