YQL-20086 ast

commit_hash:0e0d69f0fdbf5c5d7bb8e4f69f8aba70afed226a

7 files changed, 653 insertions, 653 deletions

diff --git a/yql/essentials/ast/yql_ast.h b/yql/essentials/ast/yql_ast.h
index aaae6f53a1e..83adced26c8 100644
--- a/yql/essentials/ast/yql_ast.h
+++ b/yql/essentials/ast/yql_ast.h
@@ -53,85 +53,85 @@ struct TAstNode {
     }
 
     inline EType GetType() const {
-        return Type;
+        return Type_;
     }
 
     inline bool IsAtom() const {
-        return Type == Atom;
+        return Type_ == Atom;
     }
 
     inline bool IsList() const {
-        return Type == List;
+        return Type_ == List;
     }
 
     inline bool IsListOfSize(ui32 len) const {
-        return Type == List && ListCount == len;
+        return Type_ == List && ListCount_ == len;
     }
 
     inline TPosition GetPosition() const {
-        return Position;
+        return Position_;
     }
 
     inline void SetPosition(TPosition position) {
-        Position = position;
+        Position_ = position;
     }
 
     inline TStringBuf GetContent() const {
         Y_ABORT_UNLESS(IsAtom());
-        return TStringBuf(Data.A.Content, Data.A.Size);
+        return TStringBuf(Data_.A.Content, Data_.A.Size);
     }
 
     inline void SetContent(TStringBuf newContent, TMemoryPool& pool) {
         Y_ABORT_UNLESS(IsAtom());
         auto poolContent = pool.AppendString(newContent);
-        Data.A.Content = poolContent.data();
-        Data.A.Size = poolContent.size();
+        Data_.A.Content = poolContent.data();
+        Data_.A.Size = poolContent.size();
     }
 
     inline void SetLiteralContent(TStringBuf newContent) {
         Y_ABORT_UNLESS(IsAtom());
-        Data.A.Content = newContent.data();
-        Data.A.Size = newContent.size();
+        Data_.A.Content = newContent.data();
+        Data_.A.Size = newContent.size();
     }
 
     inline ui32 GetFlags() const {
         Y_ABORT_UNLESS(IsAtom());
-        return Data.A.Flags;
+        return Data_.A.Flags;
     }
 
     inline void SetFlags(ui32 flags) {
         Y_ABORT_UNLESS(IsAtom());
-        Data.A.Flags = flags;
+        Data_.A.Flags = flags;
     }
 
     inline ui32 GetChildrenCount() const {
         Y_ABORT_UNLESS(IsList());
-        return ListCount;
+        return ListCount_;
     }
 
     inline const TAstNode* GetChild(ui32 index) const {
         Y_ABORT_UNLESS(IsList());
-        Y_ABORT_UNLESS(index < ListCount);
-        if (ListCount <= SmallListCount) {
-            return Data.S.Children[index];
+        Y_ABORT_UNLESS(index < ListCount_);
+        if (ListCount_ <= SmallListCount) {
+            return Data_.S.Children[index];
         } else {
-            return Data.L.Children[index];
+            return Data_.L.Children[index];
         }
     }
 
     inline TAstNode* GetChild(ui32 index) {
         Y_ABORT_UNLESS(IsList());
-        Y_ABORT_UNLESS(index < ListCount);
-        if (ListCount <= SmallListCount) {
-            return Data.S.Children[index];
+        Y_ABORT_UNLESS(index < ListCount_);
+        if (ListCount_ <= SmallListCount) {
+            return Data_.S.Children[index];
         } else {
-            return Data.L.Children[index];
+            return Data_.L.Children[index];
         }
     }
-    
+
     inline TArrayRef<TAstNode* const> GetChildren() const {
         Y_ABORT_UNLESS(IsList());
-        return {ListCount <= SmallListCount ? Data.S.Children : Data.L.Children, ListCount};
+        return {ListCount_ <= SmallListCount ? Data_.S.Children : Data_.L.Children, ListCount_};
     }
 
     static inline TAstNode* NewAtom(TPosition position, TStringBuf content, TMemoryPool& pool, ui32 flags = TNodeFlags::Default) {
@@ -187,37 +187,37 @@ struct TAstNode {
     inline ~TAstNode() {}
 
     void Destroy() {
-        TString().swap(Position.File);
+        TString().swap(Position_.File);
     }
 
 private:
     inline TAstNode(TPosition position, TStringBuf content, ui32 flags)
-        : Position(position)
-        , Type(Atom)
-        , ListCount(0)
+        : Position_(position)
+        , Type_(Atom)
+        , ListCount_(0)
     {
-        Data.A.Content = content.data();
-        Data.A.Size = content.size();
-        Data.A.Flags = flags;
+        Data_.A.Content = content.data();
+        Data_.A.Size = content.size();
+        Data_.A.Flags = flags;
     }
 
     inline TAstNode(TPosition position, TAstNode** children, ui32 childrenCount)
-        : Position(position)
-        , Type(List)
-        , ListCount(childrenCount)
+        : Position_(position)
+        , Type_(List)
+        , ListCount_(childrenCount)
     {
         if (childrenCount <= SmallListCount) {
             for (ui32 index = 0; index < childrenCount; ++index) {
-                Data.S.Children[index] = children[index];
+                Data_.S.Children[index] = children[index];
             }
         } else {
-            Data.L.Children = children;
+            Data_.L.Children = children;
         }
     }
 
-    TPosition Position;
-    const EType Type;
-    const ui32 ListCount;
+    TPosition Position_;
+    const EType Type_;
+    const ui32 ListCount_;
 
     struct TAtom {
         const char* Content;
@@ -237,7 +237,7 @@ private:
         TAtom A;
         TListType L;
         TSmallList S;
-    } Data;
+    } Data_;
 };
 
 enum class ESyntaxType {
diff --git a/yql/essentials/ast/yql_expr.cpp b/yql/essentials/ast/yql_expr.cpp
index fb60a08476b..c5fa94ca732 100644
--- a/yql/essentials/ast/yql_expr.cpp
+++ b/yql/essentials/ast/yql_expr.cpp
@@ -2805,7 +2805,7 @@ TExprNode::TPtr TExprContext::ExactChangeChildren(const TExprNode& node, TExprNo
     newNode->SetTypeAnn(node.GetTypeAnn());
     newNode->CopyConstraints(node);
     newNode->SetState(node.GetState());
-    newNode->Result = node.Result;
+    newNode->Result_ = node.Result_;
     ExprNodes.emplace_back(newNode.Get());
     return newNode;
 }
@@ -2816,7 +2816,7 @@ TExprNode::TPtr TExprContext::ExactShallowCopy(const TExprNode& node) {
     newNode->SetTypeAnn(node.GetTypeAnn());
     newNode->CopyConstraints(node);
     newNode->SetState(node.GetState());
-    newNode->Result = node.Result;
+    newNode->Result_ = node.Result_;
     ExprNodes.emplace_back(newNode.Get());
     return newNode;
 }
@@ -3062,7 +3062,7 @@ bool TDataExprParamsType::Validate(TPositionHandle position, TExprContext& ctx)
 }
 
 bool TItemExprType::Validate(TPosition position, TExprContext& ctx) const {
-    return ValidateName(position, Name, "member", ctx);
+    return ValidateName(position, Name_, "member", ctx);
 }
 
 bool TItemExprType::Validate(TPositionHandle position, TExprContext& ctx) const {
@@ -3071,11 +3071,11 @@ bool TItemExprType::Validate(TPositionHandle position, TExprContext& ctx) const
 
 TStringBuf TItemExprType::GetCleanName(bool isVirtual) const {
     if (!isVirtual) {
-        return Name;
+        return Name_;
     }
 
-    YQL_ENSURE(Name.StartsWith(YqlVirtualPrefix));
-    return Name.SubStr(YqlVirtualPrefix.size());
+    YQL_ENSURE(Name_.StartsWith(YqlVirtualPrefix));
+    return Name_.SubStr(YqlVirtualPrefix.size());
 }
 
 const TItemExprType* TItemExprType::GetCleanItem(bool isVirtual, TExprContext& ctx) const {
@@ -3083,13 +3083,13 @@ const TItemExprType* TItemExprType::GetCleanItem(bool isVirtual, TExprContext& c
         return this;
     }
 
-    YQL_ENSURE(Name.StartsWith(YqlVirtualPrefix));
-    return ctx.MakeType<TItemExprType>(Name.SubStr(YqlVirtualPrefix.size()), ItemType);
+    YQL_ENSURE(Name_.StartsWith(YqlVirtualPrefix));
+    return ctx.MakeType<TItemExprType>(Name_.SubStr(YqlVirtualPrefix.size()), ItemType_);
 }
 
 bool TMultiExprType::Validate(TPosition position, TExprContext& ctx) const {
-    if (Items.size() > Max<ui16>()) {
-        ctx.AddError(TIssue(position, TStringBuilder() << "Too many elements: " << Items.size()));
+    if (Items_.size() > Max<ui16>()) {
+        ctx.AddError(TIssue(position, TStringBuilder() << "Too many elements: " << Items_.size()));
         return false;
     }
 
@@ -3101,8 +3101,8 @@ bool TMultiExprType::Validate(TPositionHandle position, TExprContext& ctx) const
 }
 
 bool TTupleExprType::Validate(TPosition position, TExprContext& ctx) const {
-    if (Items.size() > Max<ui16>()) {
-        ctx.AddError(TIssue(position, TStringBuilder() << "Too many tuple elements: " << Items.size()));
+    if (Items_.size() > Max<ui16>()) {
+        ctx.AddError(TIssue(position, TStringBuilder() << "Too many tuple elements: " << Items_.size()));
         return false;
     }
 
@@ -3114,13 +3114,13 @@ bool TTupleExprType::Validate(TPositionHandle position, TExprContext& ctx) const
 }
 
 bool TStructExprType::Validate(TPosition position, TExprContext& ctx) const {
-    if (Items.size() > Max<ui16>()) {
-        ctx.AddError(TIssue(position, TStringBuilder() << "Too many struct members: " << Items.size()));
+    if (Items_.size() > Max<ui16>()) {
+        ctx.AddError(TIssue(position, TStringBuilder() << "Too many struct members: " << Items_.size()));
         return false;
     }
 
     TString lastName;
-    for (auto& item : Items) {
+    for (auto& item : Items_) {
         if (!item->Validate(position, ctx)) {
             return false;
         }
@@ -3141,20 +3141,20 @@ bool TStructExprType::Validate(TPositionHandle position, TExprContext& ctx) cons
 }
 
 bool TVariantExprType::Validate(TPosition position, TExprContext& ctx) const {
-    if (UnderlyingType->GetKind() == ETypeAnnotationKind::Tuple) {
-        if (!UnderlyingType->Cast<TTupleExprType>()->GetSize()) {
+    if (UnderlyingType_->GetKind() == ETypeAnnotationKind::Tuple) {
+        if (!UnderlyingType_->Cast<TTupleExprType>()->GetSize()) {
             ctx.AddError(TIssue(position, TStringBuilder() << "Empty tuple is not allowed as underlying type"));
             return false;
         }
     }
-    else if (UnderlyingType->GetKind() == ETypeAnnotationKind::Struct) {
-        if (!UnderlyingType->Cast<TStructExprType>()->GetSize()) {
+    else if (UnderlyingType_->GetKind() == ETypeAnnotationKind::Struct) {
+        if (!UnderlyingType_->Cast<TStructExprType>()->GetSize()) {
             ctx.AddError(TIssue(position, TStringBuilder() << "Empty struct is not allowed as underlying type"));
             return false;
         }
     }
     else {
-        ctx.AddError(TIssue(position, TStringBuilder() << "Expected tuple or struct, but got:" << *UnderlyingType));
+        ctx.AddError(TIssue(position, TStringBuilder() << "Expected tuple or struct, but got:" << *UnderlyingType_));
         return false;
     }
 
@@ -3191,15 +3191,15 @@ ui32 TVariantExprType::MakeFlags(const TTypeAnnotationNode* underlyingType) {
 
 
 bool TDictExprType::Validate(TPosition position, TExprContext& ctx) const {
-    if (KeyType->IsHashable() && KeyType->IsEquatable()) {
+    if (KeyType_->IsHashable() && KeyType_->IsEquatable()) {
         return true;
     }
 
-    if (KeyType->IsComparableInternal()) {
+    if (KeyType_->IsComparableInternal()) {
         return true;
     }
 
-    ctx.AddError(TIssue(position, TStringBuilder() << "Expected hashable and equatable or internally comparable dict key type, but got: " << *KeyType));
+    ctx.AddError(TIssue(position, TStringBuilder() << "Expected hashable and equatable or internally comparable dict key type, but got: " << *KeyType_));
     return false;
 }
 
@@ -3208,14 +3208,14 @@ bool TDictExprType::Validate(TPositionHandle position, TExprContext& ctx) const
 }
 
 bool TCallableExprType::Validate(TPosition position, TExprContext& ctx) const {
-    if (OptionalArgumentsCount > Arguments.size()) {
-        ctx.AddError(TIssue(position, TStringBuilder() << "Too many optional arguments: " << OptionalArgumentsCount
-            << ", function has only " << Arguments.size() << " arguments"));
+    if (OptionalArgumentsCount_ > Arguments_.size()) {
+        ctx.AddError(TIssue(position, TStringBuilder() << "Too many optional arguments: " << OptionalArgumentsCount_
+            << ", function has only " << Arguments_.size() << " arguments"));
         return false;
     }
 
-    for (ui32 index = Arguments.size() - OptionalArgumentsCount; index < Arguments.size(); ++index) {
-        auto type = Arguments[index].Type;
+    for (ui32 index = Arguments_.size() - OptionalArgumentsCount_; index < Arguments_.size(); ++index) {
+        auto type = Arguments_[index].Type;
         if (type->GetKind() != ETypeAnnotationKind::Optional) {
             ctx.AddError(TIssue(position, TStringBuilder() << "Expected optional type for argument: " << (index + 1)
                 << " because it's an optional argument, but got: " << *type));
@@ -3224,9 +3224,9 @@ bool TCallableExprType::Validate(TPosition position, TExprContext& ctx) const {
     }
 
     bool startedNames = false;
-    std::unordered_set<std::string_view> usedNames(Arguments.size());
-    for (ui32 index = 0; index < Arguments.size(); ++index) {
-        bool hasName = !Arguments[index].Name.empty();
+    std::unordered_set<std::string_view> usedNames(Arguments_.size());
+    for (ui32 index = 0; index < Arguments_.size(); ++index) {
+        bool hasName = !Arguments_[index].Name.empty();
         if (startedNames) {
             if (!hasName) {
                 ctx.AddError(TIssue(position, TStringBuilder() << "Unexpected positional argument at position "
@@ -3238,8 +3238,8 @@ bool TCallableExprType::Validate(TPosition position, TExprContext& ctx) const {
         }
 
         if (hasName) {
-            if (!usedNames.insert(Arguments[index].Name).second) {
-                ctx.AddError(TIssue(position, TStringBuilder() << "Duplication of named argument: " << Arguments[index].Name));
+            if (!usedNames.insert(Arguments_[index].Name).second) {
+                ctx.AddError(TIssue(position, TStringBuilder() << "Duplication of named argument: " << Arguments_[index].Name));
                 return false;
             }
         }
@@ -3253,7 +3253,7 @@ bool TCallableExprType::Validate(TPositionHandle position, TExprContext& ctx) co
 }
 
 bool TTaggedExprType::Validate(TPosition position, TExprContext& ctx) const {
-    return ValidateName(position, Tag, "tag", ctx);
+    return ValidateName(position, Tag_, "tag", ctx);
 }
 
 bool TTaggedExprType::Validate(TPositionHandle position, TExprContext& ctx) const {
@@ -3261,7 +3261,7 @@ bool TTaggedExprType::Validate(TPositionHandle position, TExprContext& ctx) cons
 }
 
 const TString& TPgExprType::GetName() const {
-    return NPg::LookupType(TypeId).Name;
+    return NPg::LookupType(TypeId_).Name;
 }
 
 ui32 TPgExprType::GetFlags(ui32 typeId) {
@@ -3329,14 +3329,14 @@ TExprContext::TExprContext(ui64 nextUniqueId)
     : StringPool(4096)
     , NextUniqueId(nextUniqueId)
     , Frozen(false)
-    , PositionSet(
+    , PositionSet_(
         16,
         [this](TPositionHandle p) { return GetHash(p); },
         [this](TPositionHandle a, TPositionHandle b) { return IsEqual(a, b); }
     )
 {
     auto handle = AppendPosition(TPosition());
-    YQL_ENSURE(handle.Handle == 0);
+    YQL_ENSURE(handle.Handle_ == 0);
     IssueManager.SetWarningToErrorTreatMessage(
         "Treat warning as error mode enabled. "
         "To disable it use \"pragma warning(\"default\", <code>);\"");
@@ -3344,24 +3344,24 @@ TExprContext::TExprContext(ui64 nextUniqueId)
 }
 
 TPositionHandle TExprContext::AppendPosition(const TPosition& pos) {
-    YQL_ENSURE(Positions.size() <= Max<ui32>(), "Too many positions");
+    YQL_ENSURE(Positions_.size() <= Max<ui32>(), "Too many positions");
 
     TPositionHandle handle;
-    handle.Handle = (ui32)Positions.size();
-    Positions.push_back(pos);
+    handle.Handle_ = (ui32)Positions_.size();
+    Positions_.push_back(pos);
 
-    auto inserted = PositionSet.insert(handle);
+    auto inserted = PositionSet_.insert(handle);
     if (inserted.second) {
         return handle;
     }
 
-    Positions.pop_back();
+    Positions_.pop_back();
     return *inserted.first;
 }
 
 TPosition TExprContext::GetPosition(TPositionHandle handle) const {
-    YQL_ENSURE(handle.Handle < Positions.size(), "Unknown PositionHandle");
-    return Positions[handle.Handle];
+    YQL_ENSURE(handle.Handle_ < Positions_.size(), "Unknown PositionHandle");
+    return Positions_[handle.Handle_];
 }
 
 TExprContext::~TExprContext() {
@@ -3395,15 +3395,15 @@ void TExprContext::Reset() {
 }
 
 bool TExprContext::IsEqual(TPositionHandle a, TPositionHandle b) const {
-    YQL_ENSURE(a.Handle < Positions.size());
-    YQL_ENSURE(b.Handle < Positions.size());
-    return Positions[a.Handle] == Positions[b.Handle];
+    YQL_ENSURE(a.Handle_ < Positions_.size());
+    YQL_ENSURE(b.Handle_ < Positions_.size());
+    return Positions_[a.Handle_] == Positions_[b.Handle_];
 }
 
 size_t TExprContext::GetHash(TPositionHandle p) const {
-    YQL_ENSURE(p.Handle < Positions.size());
+    YQL_ENSURE(p.Handle_ < Positions_.size());
 
-    const TPosition& pos = Positions[p.Handle];
+    const TPosition& pos = Positions_[p.Handle_];
     size_t h = ComputeHash(pos.File);
     h = CombineHashes(h, NumericHash(pos.Row));
     return CombineHashes(h, NumericHash(pos.Column));
@@ -3682,27 +3682,27 @@ bool CompareExprTreeParts(const TExprNode& one, const TExprNode& two, const TNod
 class TCacheKeyBuilder {
 public:
     TString Process(const TExprNode& root) {
-        SHA256_Init(&Sha);
+        SHA256_Init(&Sha_);
         unsigned char hash[SHA256_DIGEST_LENGTH];
         Visit(root);
-        SHA256_Final(hash, &Sha);
+        SHA256_Final(hash, &Sha_);
         return TString((const char*)hash, sizeof(hash));
     }
 
 private:
     void Visit(const TExprNode& node) {
-        auto [it, inserted] = Visited.emplace(&node, Visited.size());
-        SHA256_Update(&Sha, &it->second, sizeof(it->second));
+        auto [it, inserted] = Visited_.emplace(&node, Visited_.size());
+        SHA256_Update(&Sha_, &it->second, sizeof(it->second));
         if (!inserted) {
             return;
         }
 
         ui32 type = node.Type();
-        SHA256_Update(&Sha, &type, sizeof(type));
+        SHA256_Update(&Sha_, &type, sizeof(type));
         if (node.Type() == TExprNode::EType::Atom || node.Type() == TExprNode::EType::Callable) {
             ui32 textLen = node.Content().size();
-            SHA256_Update(&Sha, &textLen, sizeof(textLen));
-            SHA256_Update(&Sha, node.Content().data(), textLen);
+            SHA256_Update(&Sha_, &textLen, sizeof(textLen));
+            SHA256_Update(&Sha_, node.Content().data(), textLen);
         }
 
         if (node.Type() == TExprNode::EType::Atom || node.Type() == TExprNode::EType::Argument || node.Type() == TExprNode::EType::World) {
@@ -3710,15 +3710,15 @@ private:
         }
 
         ui32 len = node.ChildrenSize();
-        SHA256_Update(&Sha, &len, sizeof(len));
+        SHA256_Update(&Sha_, &len, sizeof(len));
         for (const auto& child : node.Children()) {
             Visit(*child);
         }
     }
 
 private:
-    SHA256_CTX Sha;
-    TNodeMap<ui64> Visited;
+    SHA256_CTX Sha_;
+    TNodeMap<ui64> Visited_;
 };
 
 TString MakeCacheKey(const TExprNode& root) {
diff --git a/yql/essentials/ast/yql_expr.h b/yql/essentials/ast/yql_expr.h
index 5becfbb3e31..10165414f38 100644
--- a/yql/essentials/ast/yql_expr.h
+++ b/yql/essentials/ast/yql_expr.h
@@ -197,10 +197,10 @@ void ReportError(TExprContext& ctx, const TIssue& issue);
 class TTypeAnnotationNode {
 protected:
     TTypeAnnotationNode(ETypeAnnotationKind kind, ui32 flags, ui64 hash, ui64 usedPgExtensions)
-        : Kind(kind)
-        , Flags(flags)
-        , Hash(hash)
-        , UsedPgExtensions(usedPgExtensions)
+        : Kind_(kind)
+        , Flags_(flags)
+        , Hash_(hash)
+        , UsedPgExtensions_(usedPgExtensions)
     {
     }
 
@@ -231,7 +231,7 @@ public:
     }
 
     ETypeAnnotationKind GetKind() const {
-        return Kind;
+        return Kind_;
     }
 
     bool ReturnsWorld() const;
@@ -322,15 +322,15 @@ public:
     }
 
     ui32 GetFlags() const {
-        return Flags;
+        return Flags_;
     }
 
     ui64 GetHash() const {
-        return Hash;
+        return Hash_;
     }
 
     ui64 GetUsedPgExtensions() const {
-        return UsedPgExtensions;
+        return UsedPgExtensions_;
     }
 
     bool Equals(const TTypeAnnotationNode& node) const;
@@ -376,10 +376,10 @@ protected:
     }
 
 private:
-    const ETypeAnnotationKind Kind;
-    const ui32 Flags;
-    const ui64 Hash;
-    const ui64 UsedPgExtensions;
+    const ETypeAnnotationKind Kind_;
+    const ui32 Flags_;
+    const ui64 Hash_;
+    const ui64 UsedPgExtensions_;
 };
 
 class TUnitExprType : public TTypeAnnotationNode {
@@ -408,7 +408,7 @@ public:
 
     TTupleExprType(ui64 hash, const TTypeAnnotationNode::TListType& items)
         : TTypeAnnotationNode(KindValue, CombineFlags(items), hash, CombinePgExtensions(items))
-        , Items(items)
+        , Items_(items)
     {
     }
 
@@ -423,11 +423,11 @@ public:
     }
 
     size_t GetSize() const {
-        return Items.size();
+        return Items_.size();
     }
 
     const TTypeAnnotationNode::TListType& GetItems() const {
-        return Items;
+        return Items_;
     }
 
     bool operator==(const TTupleExprType& other) const {
@@ -448,7 +448,7 @@ public:
     bool Validate(TPositionHandle position, TExprContext& ctx) const;
 
 private:
-    TTypeAnnotationNode::TListType Items;
+    TTypeAnnotationNode::TListType Items_;
 };
 
 class TMultiExprType : public TTypeAnnotationNode {
@@ -457,7 +457,7 @@ public:
 
     TMultiExprType(ui64 hash, const TTypeAnnotationNode::TListType& items)
         : TTypeAnnotationNode(KindValue, CombineFlags(items), hash, CombinePgExtensions(items))
-        , Items(items)
+        , Items_(items)
     {
     }
 
@@ -472,11 +472,11 @@ public:
     }
 
     size_t GetSize() const {
-        return Items.size();
+        return Items_.size();
     }
 
     const TTypeAnnotationNode::TListType& GetItems() const {
-        return Items;
+        return Items_;
     }
 
     bool operator==(const TMultiExprType& other) const {
@@ -497,7 +497,7 @@ public:
     bool Validate(TPositionHandle position, TExprContext& ctx) const;
 
 private:
-    TTypeAnnotationNode::TListType Items;
+    TTypeAnnotationNode::TListType Items_;
 };
 
 struct TExprContext;
@@ -512,8 +512,8 @@ public:
 
     TItemExprType(ui64 hash, const TStringBuf& name, const TTypeAnnotationNode* itemType)
         : TTypeAnnotationNode(KindValue, itemType->GetFlags(), hash, itemType->GetUsedPgExtensions())
-        , Name(name)
-        , ItemType(itemType)
+        , Name_(name)
+        , ItemType_(itemType)
     {
     }
 
@@ -528,13 +528,13 @@ public:
     bool Validate(TPositionHandle position, TExprContext& ctx) const;
 
     const TStringBuf& GetName() const {
-        return Name;
+        return Name_;
     }
 
     TStringBuf GetCleanName(bool isVirtual) const;
 
     const TTypeAnnotationNode* GetItemType() const {
-        return ItemType;
+        return ItemType_;
     }
 
     bool operator==(const TItemExprType& other) const {
@@ -544,8 +544,8 @@ public:
     const TItemExprType* GetCleanItem(bool isVirtual, TExprContext& ctx) const;
 
 private:
-    const TStringBuf Name;
-    const TTypeAnnotationNode* ItemType;
+    const TStringBuf Name_;
+    const TTypeAnnotationNode* ItemType_;
 };
 
 class TStructExprType : public TTypeAnnotationNode {
@@ -568,7 +568,7 @@ public:
 
     TStructExprType(ui64 hash, const TVector<const TItemExprType*>& items)
         : TTypeAnnotationNode(KindValue, TypeNonComparable | CombineFlags(items), hash, CombinePgExtensions(items))
-        , Items(items)
+        , Items_(items)
     {
     }
 
@@ -587,20 +587,20 @@ public:
     bool Validate(TPositionHandle position, TExprContext& ctx) const;
 
     size_t GetSize() const {
-        return Items.size();
+        return Items_.size();
     }
 
     const TVector<const TItemExprType*>& GetItems() const {
-        return Items;
+        return Items_;
     }
 
     TMaybe<ui32> FindItem(const TStringBuf& name) const {
-        auto it = LowerBound(Items.begin(), Items.end(), name, TItemLess());
-        if (it == Items.end() || (*it)->GetName() != name) {
+        auto it = LowerBound(Items_.begin(), Items_.end(), name, TItemLess());
+        if (it == Items_.end() || (*it)->GetName() != name) {
             return TMaybe<ui32>();
         }
 
-        return it - Items.begin();
+        return it - Items_.begin();
     }
 
     TMaybe<ui32> FindItemI(const TStringBuf& name, bool* isVirtual) const {
@@ -616,8 +616,8 @@ public:
             }
 
             TMaybe<ui32> ret;
-            for (ui32 i = 0; i < Items.size(); ++i) {
-                if (AsciiEqualsIgnoreCase(nameToSearch, Items[i]->GetName())) {
+            for (ui32 i = 0; i < Items_.size(); ++i) {
+                if (AsciiEqualsIgnoreCase(nameToSearch, Items_[i]->GetName())) {
                     if (ret) {
                         return Nothing();
                     }
@@ -635,8 +635,8 @@ public:
     }
 
     const TTypeAnnotationNode* FindItemType(const TStringBuf& name) const {
-        const auto it = LowerBound(Items.begin(), Items.end(), name, TItemLess());
-        if (it == Items.end() || (*it)->GetName() != name) {
+        const auto it = LowerBound(Items_.begin(), Items_.end(), name, TItemLess());
+        if (it == Items_.end() || (*it)->GetName() != name) {
             return nullptr;
         }
 
@@ -644,7 +644,7 @@ public:
     }
 
     TMaybe<TStringBuf> FindMistype(const TStringBuf& name) const {
-        for (const auto& item: Items) {
+        for (const auto& item: Items_) {
             if (NLevenshtein::Distance(name, item->GetName()) < DefaultMistypeDistance) {
                 return item->GetName();
             }
@@ -670,9 +670,9 @@ public:
     TString ToString() const {
         TStringBuilder sb;
 
-        for (std::size_t i = 0; i < Items.size(); i++) {
-            sb << i << ": " << Items[i]->GetName() << "(" << FormatType(Items[i]->GetItemType()) << ")";
-            if (i != Items.size() - 1) {
+        for (std::size_t i = 0; i < Items_.size(); i++) {
+            sb << i << ": " << Items_[i]->GetName() << "(" << FormatType(Items_[i]->GetItemType()) << ")";
+            if (i != Items_.size() - 1) {
                 sb << ", ";
             }
         }
@@ -681,7 +681,7 @@ public:
     }
 
 private:
-    TVector<const TItemExprType*> Items;
+    TVector<const TItemExprType*> Items_;
 };
 
 class TListExprType : public TTypeAnnotationNode {
@@ -690,7 +690,7 @@ public:
 
     TListExprType(ui64 hash, const TTypeAnnotationNode* itemType)
         : TTypeAnnotationNode(KindValue, itemType->GetFlags() | TypeHasDynamicSize, hash, itemType->GetUsedPgExtensions())
-        , ItemType(itemType)
+        , ItemType_(itemType)
     {
     }
 
@@ -700,7 +700,7 @@ public:
     }
 
     const TTypeAnnotationNode* GetItemType() const {
-        return ItemType;
+        return ItemType_;
     }
 
     bool operator==(const TListExprType& other) const {
@@ -708,7 +708,7 @@ public:
     }
 
 private:
-    const TTypeAnnotationNode* ItemType;
+    const TTypeAnnotationNode* ItemType_;
 };
 
 class TStreamExprType : public TTypeAnnotationNode {
@@ -717,7 +717,7 @@ public:
 
     TStreamExprType(ui64 hash, const TTypeAnnotationNode* itemType)
         : TTypeAnnotationNode(KindValue, itemType->GetFlags() | TypeNonPersistable, hash, itemType->GetUsedPgExtensions())
-        , ItemType(itemType)
+        , ItemType_(itemType)
     {
     }
 
@@ -727,7 +727,7 @@ public:
     }
 
     const TTypeAnnotationNode* GetItemType() const {
-        return ItemType;
+        return ItemType_;
     }
 
     bool operator==(const TStreamExprType& other) const {
@@ -735,7 +735,7 @@ public:
     }
 
 private:
-    const TTypeAnnotationNode* ItemType;
+    const TTypeAnnotationNode* ItemType_;
 };
 
 class TFlowExprType : public TTypeAnnotationNode {
@@ -744,7 +744,7 @@ public:
 
     TFlowExprType(ui64 hash, const TTypeAnnotationNode* itemType)
         : TTypeAnnotationNode(KindValue, itemType->GetFlags() | TypeNonPersistable, hash, itemType->GetUsedPgExtensions())
-        , ItemType(itemType)
+        , ItemType_(itemType)
     {
     }
 
@@ -754,7 +754,7 @@ public:
     }
 
     const TTypeAnnotationNode* GetItemType() const {
-        return ItemType;
+        return ItemType_;
     }
 
     bool operator==(const TFlowExprType& other) const {
@@ -762,7 +762,7 @@ public:
     }
 
 private:
-    const TTypeAnnotationNode* ItemType;
+    const TTypeAnnotationNode* ItemType_;
 };
 
 class TBlockExprType : public TTypeAnnotationNode {
@@ -771,7 +771,7 @@ public:
 
     TBlockExprType(ui64 hash, const TTypeAnnotationNode* itemType)
         : TTypeAnnotationNode(KindValue, itemType->GetFlags() | TypeNonPersistable, hash, itemType->GetUsedPgExtensions())
-        , ItemType(itemType)
+        , ItemType_(itemType)
     {
     }
 
@@ -781,7 +781,7 @@ public:
     }
 
     const TTypeAnnotationNode* GetItemType() const {
-        return ItemType;
+        return ItemType_;
     }
 
     bool operator==(const TBlockExprType& other) const {
@@ -789,7 +789,7 @@ public:
     }
 
 private:
-    const TTypeAnnotationNode* ItemType;
+    const TTypeAnnotationNode* ItemType_;
 };
 
 class TScalarExprType : public TTypeAnnotationNode {
@@ -798,7 +798,7 @@ public:
 
     TScalarExprType(ui64 hash, const TTypeAnnotationNode* itemType)
         : TTypeAnnotationNode(KindValue, itemType->GetFlags() | TypeNonPersistable, hash, itemType->GetUsedPgExtensions())
-        , ItemType(itemType)
+        , ItemType_(itemType)
     {
     }
 
@@ -808,7 +808,7 @@ public:
     }
 
     const TTypeAnnotationNode* GetItemType() const {
-        return ItemType;
+        return ItemType_;
     }
 
     bool operator==(const TScalarExprType& other) const {
@@ -816,7 +816,7 @@ public:
     }
 
 private:
-    const TTypeAnnotationNode* ItemType;
+    const TTypeAnnotationNode* ItemType_;
 };
 
 class TDataExprType : public TTypeAnnotationNode {
@@ -825,7 +825,7 @@ public:
 
     TDataExprType(ui64 hash, EDataSlot slot)
         : TTypeAnnotationNode(KindValue, GetFlags(slot), hash, 0)
-        , Slot(slot)
+        , Slot_(slot)
     {
     }
 
@@ -864,25 +864,25 @@ public:
     }
 
     EDataSlot GetSlot() const {
-        return Slot;
+        return Slot_;
     }
 
     TStringBuf GetName() const {
-        return NUdf::GetDataTypeInfo(Slot).Name;
+        return NUdf::GetDataTypeInfo(Slot_).Name;
     }
 
     bool operator==(const TDataExprType& other) const {
-        return Slot == other.Slot;
+        return Slot_ == other.Slot_;
     }
 
 private:
-    EDataSlot Slot;
+    EDataSlot Slot_;
 };
 
 class TDataExprParamsType : public TDataExprType {
 public:
     TDataExprParamsType(ui64 hash, EDataSlot slot, const TStringBuf& one, const TStringBuf& two)
-        : TDataExprType(hash, slot), One(one), Two(two)
+        : TDataExprType(hash, slot), One_(one), Two_(two)
     {}
 
     static ui64 MakeHash(EDataSlot slot, const TStringBuf& one, const TStringBuf& two) {
@@ -895,11 +895,11 @@ public:
     }
 
     const TStringBuf& GetParamOne() const {
-        return One;
+        return One_;
     }
 
     const TStringBuf& GetParamTwo() const {
-        return Two;
+        return Two_;
     }
 
     bool operator==(const TDataExprParamsType& other) const {
@@ -910,7 +910,7 @@ public:
     bool Validate(TPositionHandle position, TExprContext& ctx) const;
 
 private:
-    const TStringBuf One, Two;
+    const TStringBuf One_, Two_;
 };
 
 class TPgExprType : public TTypeAnnotationNode {
@@ -920,7 +920,7 @@ public:
     // TODO: TypeHasDynamicSize for Pg types
     TPgExprType(ui64 hash, ui32 typeId)
         : TTypeAnnotationNode(KindValue, GetFlags(typeId), hash, GetPgExtensionsMask(typeId))
-        , TypeId(typeId)
+        , TypeId_(typeId)
     {
     }
 
@@ -932,11 +932,11 @@ public:
     const TString& GetName() const;
 
     ui32 GetId() const {
-        return TypeId;
+        return TypeId_;
     }
 
     bool operator==(const TPgExprType& other) const {
-        return TypeId == other.TypeId;
+        return TypeId_ == other.TypeId_;
     }
 
 private:
@@ -944,7 +944,7 @@ private:
     ui64 GetPgExtensionsMask(ui32 typeId);
 
 private:
-    ui32 TypeId;
+    ui32 TypeId_;
 };
 
 ui64 MakePgExtensionMask(ui32 extensionIndex);
@@ -975,7 +975,7 @@ public:
 
     TOptionalExprType(ui64 hash, const TTypeAnnotationNode* itemType)
         : TTypeAnnotationNode(KindValue, GetFlags(itemType), hash, itemType->GetUsedPgExtensions())
-        , ItemType(itemType)
+        , ItemType_(itemType)
     {
     }
 
@@ -998,7 +998,7 @@ public:
     }
 
     const TTypeAnnotationNode* GetItemType() const {
-        return ItemType;
+        return ItemType_;
     }
 
     bool operator==(const TOptionalExprType& other) const {
@@ -1006,7 +1006,7 @@ public:
     }
 
 private:
-    const TTypeAnnotationNode* ItemType;
+    const TTypeAnnotationNode* ItemType_;
 };
 
 class TVariantExprType : public TTypeAnnotationNode {
@@ -1015,7 +1015,7 @@ public:
 
     TVariantExprType(ui64 hash, const TTypeAnnotationNode* underlyingType)
         : TTypeAnnotationNode(KindValue, MakeFlags(underlyingType), hash, underlyingType->GetUsedPgExtensions())
-        , UnderlyingType(underlyingType)
+        , UnderlyingType_(underlyingType)
     {
     }
 
@@ -1025,7 +1025,7 @@ public:
     }
 
     const TTypeAnnotationNode* GetUnderlyingType() const {
-        return UnderlyingType;
+        return UnderlyingType_;
     }
 
     bool operator==(const TVariantExprType& other) const {
@@ -1038,7 +1038,7 @@ public:
     static ui32 MakeFlags(const TTypeAnnotationNode* underlyingType);
 
 private:
-    const TTypeAnnotationNode* UnderlyingType;
+    const TTypeAnnotationNode* UnderlyingType_;
 };
 
 class TTypeExprType : public TTypeAnnotationNode {
@@ -1047,7 +1047,7 @@ public:
 
     TTypeExprType(ui64 hash, const TTypeAnnotationNode* type)
         : TTypeAnnotationNode(KindValue, TypeNonPersistable | TypeNonComputable | (type->GetFlags() & TypeHasError), hash, 0)
-        , Type(type)
+        , Type_(type)
     {
     }
 
@@ -1057,7 +1057,7 @@ public:
     }
 
     const TTypeAnnotationNode* GetType() const {
-        return Type;
+        return Type_;
     }
 
     bool operator==(const TTypeExprType& other) const {
@@ -1065,7 +1065,7 @@ public:
     }
 
 private:
-    const TTypeAnnotationNode* Type;
+    const TTypeAnnotationNode* Type_;
 };
 
 class TDictExprType : public TTypeAnnotationNode {
@@ -1076,8 +1076,8 @@ public:
         : TTypeAnnotationNode(KindValue, TypeNonComparable | TypeHasDynamicSize |
                               keyType->GetFlags() | payloadType->GetFlags(), hash,
                               keyType->GetUsedPgExtensions() | payloadType->GetUsedPgExtensions())
-        , KeyType(keyType)
-        , PayloadType(payloadType)
+        , KeyType_(keyType)
+        , PayloadType_(payloadType)
     {
     }
 
@@ -1090,11 +1090,11 @@ public:
     bool Validate(TPositionHandle position, TExprContext& ctx) const;
 
     const TTypeAnnotationNode* GetKeyType() const {
-        return KeyType;
+        return KeyType_;
     }
 
     const TTypeAnnotationNode* GetPayloadType() const {
-        return PayloadType;
+        return PayloadType_;
     }
 
     bool operator==(const TDictExprType& other) const {
@@ -1103,8 +1103,8 @@ public:
     }
 
 private:
-    const TTypeAnnotationNode* KeyType;
-    const TTypeAnnotationNode* PayloadType;
+    const TTypeAnnotationNode* KeyType_;
+    const TTypeAnnotationNode* PayloadType_;
 };
 
 class TVoidExprType : public TTypeAnnotationNode {
@@ -1166,15 +1166,15 @@ public:
     TCallableExprType(ui64 hash, const TTypeAnnotationNode* returnType, const TVector<TArgumentInfo>& arguments
         , size_t optionalArgumentsCount, const TStringBuf& payload)
         : TTypeAnnotationNode(KindValue, MakeFlags(arguments, returnType), hash, returnType->GetUsedPgExtensions())
-        , ReturnType(returnType)
-        , Arguments(arguments)
-        , OptionalArgumentsCount(optionalArgumentsCount)
-        , Payload(payload)
+        , ReturnType_(returnType)
+        , Arguments_(arguments)
+        , OptionalArgumentsCount_(optionalArgumentsCount)
+        , Payload_(payload)
     {
-        for (ui32 i = 0; i < Arguments.size(); ++i) {
-            const auto& arg = Arguments[i];
+        for (ui32 i = 0; i < Arguments_.size(); ++i) {
+            const auto& arg = Arguments_[i];
             if (!arg.Name.empty()) {
-                IndexByName.insert({ arg.Name, i });
+                IndexByName_.insert({ arg.Name, i });
             }
         }
     }
@@ -1198,23 +1198,23 @@ public:
     }
 
     const TTypeAnnotationNode* GetReturnType() const {
-        return ReturnType;
+        return ReturnType_;
     }
 
     size_t GetOptionalArgumentsCount() const {
-        return OptionalArgumentsCount;
+        return OptionalArgumentsCount_;
     }
 
     const TStringBuf& GetPayload() const {
-        return Payload;
+        return Payload_;
     }
 
     size_t GetArgumentsSize() const {
-        return Arguments.size();
+        return Arguments_.size();
     }
 
     const TVector<TArgumentInfo>& GetArguments() const {
-        return Arguments;
+        return Arguments_;
     }
 
     bool operator==(const TCallableExprType& other) const {
@@ -1243,8 +1243,8 @@ public:
     bool Validate(TPositionHandle position, TExprContext& ctx) const;
 
     TMaybe<ui32> ArgumentIndexByName(const TStringBuf& name) const {
-        auto it = IndexByName.find(name);
-        if (it == IndexByName.end()) {
+        auto it = IndexByName_.find(name);
+        if (it == IndexByName_.end()) {
             return {};
         }
 
@@ -1263,11 +1263,11 @@ private:
     }
 
 private:
-    const TTypeAnnotationNode* ReturnType;
-    TVector<TArgumentInfo> Arguments;
-    const size_t OptionalArgumentsCount;
-    const TStringBuf Payload;
-    THashMap<TStringBuf, ui32> IndexByName;
+    const TTypeAnnotationNode* ReturnType_;
+    TVector<TArgumentInfo> Arguments_;
+    const size_t OptionalArgumentsCount_;
+    const TStringBuf Payload_;
+    THashMap<TStringBuf, ui32> IndexByName_;
 };
 
 class TGenericExprType : public TTypeAnnotationNode {
@@ -1295,7 +1295,7 @@ public:
 
     TResourceExprType(ui64 hash, const TStringBuf& tag)
         : TTypeAnnotationNode(KindValue, TypeNonPersistable | TypeHasManyValues, hash, 0)
-        , Tag(tag)
+        , Tag_(tag)
     {}
 
     static ui64 MakeHash(const TStringBuf& tag) {
@@ -1305,15 +1305,15 @@ public:
     }
 
     const TStringBuf& GetTag() const {
-        return Tag;
+        return Tag_;
     }
 
     bool operator==(const TResourceExprType& other) const {
-        return Tag == other.Tag;
+        return Tag_ == other.Tag_;
     }
 
 private:
-    const TStringBuf Tag;
+    const TStringBuf Tag_;
 };
 
 class TTaggedExprType : public TTypeAnnotationNode {
@@ -1322,8 +1322,8 @@ public:
 
     TTaggedExprType(ui64 hash, const TTypeAnnotationNode* baseType, const TStringBuf& tag)
         : TTypeAnnotationNode(KindValue, baseType->GetFlags(), hash, baseType->GetUsedPgExtensions())
-        , BaseType(baseType)
-        , Tag(tag)
+        , BaseType_(baseType)
+        , Tag_(tag)
     {}
 
     static ui64 MakeHash(const TTypeAnnotationNode* baseType, const TStringBuf& tag) {
@@ -1334,23 +1334,23 @@ public:
     }
 
     const TStringBuf& GetTag() const {
-        return Tag;
+        return Tag_;
     }
 
     const TTypeAnnotationNode* GetBaseType() const {
-        return BaseType;
+        return BaseType_;
     }
 
     bool operator==(const TTaggedExprType& other) const {
-        return Tag == other.Tag && GetBaseType() == other.GetBaseType();
+        return Tag_ == other.Tag_ && GetBaseType() == other.GetBaseType();
     }
 
     bool Validate(TPosition position, TExprContext& ctx) const;
     bool Validate(TPositionHandle position, TExprContext& ctx) const;
 
 private:
-    const TTypeAnnotationNode* BaseType;
-    const TStringBuf Tag;
+    const TTypeAnnotationNode* BaseType_;
+    const TStringBuf Tag_;
 };
 
 class TErrorExprType : public TTypeAnnotationNode {
@@ -1359,7 +1359,7 @@ public:
 
     TErrorExprType(ui64 hash, const TIssue& error)
         : TTypeAnnotationNode(KindValue, TypeHasError, hash, 0)
-        , Error(error)
+        , Error_(error)
     {}
 
     static ui64 MakeHash(const TIssue& error) {
@@ -1367,15 +1367,15 @@ public:
     }
 
     const TIssue& GetError() const {
-        return Error;
+        return Error_;
     }
 
     bool operator==(const TErrorExprType& other) const {
-        return Error == other.Error;
+        return Error_ == other.Error_;
     }
 
 private:
-    const TIssue Error;
+    const TIssue Error_;
 };
 
 class TEmptyListExprType : public TTypeAnnotationNode {
@@ -1417,11 +1417,11 @@ public:
 };
 
 inline bool TTypeAnnotationNode::ReturnsWorld() const {
-    if (Kind == ETypeAnnotationKind::World) {
+    if (Kind_ == ETypeAnnotationKind::World) {
         return true;
     }
 
-    if (Kind == ETypeAnnotationKind::Tuple) {
+    if (Kind_ == ETypeAnnotationKind::Tuple) {
         auto tuple = static_cast<const TTupleExprType*>(this);
         if (tuple->GetSize() == 2 && tuple->GetItems()[0]->GetKind() == ETypeAnnotationKind::World) {
             return true;
@@ -1436,15 +1436,15 @@ inline bool TTypeAnnotationNode::Equals(const TTypeAnnotationNode& node) const {
         return true;
     }
 
-    if (Hash != node.GetHash()) {
+    if (Hash_ != node.GetHash()) {
         return false;
     }
 
-    if (Kind != node.GetKind()) {
+    if (Kind_ != node.GetKind()) {
         return false;
     }
 
-    switch (Kind) {
+    switch (Kind_) {
     case ETypeAnnotationKind::Unit:
         return static_cast<const TUnitExprType&>(*this) == static_cast<const TUnitExprType&>(node);
 
@@ -1531,7 +1531,7 @@ inline bool TTypeAnnotationNode::Equals(const TTypeAnnotationNode& node) const {
 }
 
 inline void TTypeAnnotationNode::Accept(TTypeAnnotationVisitor& visitor) const {
-    switch (Kind) {
+    switch (Kind_) {
     case ETypeAnnotationKind::Unit:
         return visitor.Visit(static_cast<const TUnitExprType&>(*this));
     case ETypeAnnotationKind::Tuple:
@@ -1650,7 +1650,7 @@ public:
     };
 
     static TPtr GetResult(const TPtr& node) {
-        return node->Type() == Callable ? node->Result : node;
+        return node->Type() == Callable ? node->Result_ : node;
     }
 
     const TExprNode& GetResult() const {
@@ -1659,37 +1659,37 @@ public:
             return *this;
         }
 
-        YQL_ENSURE(Result);
-        return *Result;
+        YQL_ENSURE(Result_);
+        return *Result_;
     }
 
     bool HasResult() const {
         ENSURE_NOT_DELETED
-        return bool(Result);
+        return bool(Result_);
     }
 
     void SetResult(TPtr&& result) {
         ENSURE_NOT_DELETED
         ENSURE_NOT_FROZEN
-        Result = std::move(result);
+        Result_ = std::move(result);
     }
 
     const std::shared_ptr<TListType>& GetWorldLinks() const {
         ENSURE_NOT_DELETED
         ENSURE_NOT_FROZEN
-        return WorldLinks;
+        return WorldLinks_;
     }
 
     std::shared_ptr<TListType>& GetWorldLinks() {
         ENSURE_NOT_DELETED
         ENSURE_NOT_FROZEN
-        return WorldLinks;
+        return WorldLinks_;
     }
 
     void SetWorldLinks(std::shared_ptr<TListType>&& links) {
         ENSURE_NOT_DELETED
         ENSURE_NOT_FROZEN
-        WorldLinks = std::move(links);
+        WorldLinks_ = std::move(links);
     }
 
     bool IsCallable(const std::string_view& name) const {
@@ -1775,13 +1775,13 @@ public:
 
     bool ForDisclosing() const {
         ENSURE_NOT_DELETED
-        return Type() == TExprNode::List && ShallBeDisclosed;
+        return Type() == TExprNode::List && ShallBeDisclosed_;
     }
 
     void SetDisclosing() {
         ENSURE_NOT_DELETED
         Y_ENSURE(Type() == TExprNode::List, "Must be list.");
-        ShallBeDisclosed = true;
+        ShallBeDisclosed_ = true;
     }
 
     ui32 GetFlagsToCompare() const {
@@ -1798,26 +1798,26 @@ public:
 
     bool StartsExecution() const {
         ENSURE_NOT_DELETED
-        return State == EState::ExecutionComplete
-            || State == EState::ExecutionInProgress
-            || State == EState::ExecutionRequired
-            || State == EState::ExecutionPending
+        return State_ == EState::ExecutionComplete
+            || State_ == EState::ExecutionInProgress
+            || State_ == EState::ExecutionRequired
+            || State_ == EState::ExecutionPending
             || HasResult();
     }
 
     bool IsComplete() const {
-        YQL_ENSURE(HasLambdaScope);
-        return !OuterLambda;
+        YQL_ENSURE(HasLambdaScope_);
+        return !OuterLambda_;
     }
 
     bool IsLiteralList() const {
         YQL_ENSURE(IsList());
-        return LiteralList;
+        return LiteralList_;
     }
 
     void SetLiteralList(bool literal) {
         YQL_ENSURE(IsList());
-        LiteralList = literal;
+        LiteralList_ = literal;
     }
 
     void Ref() {
@@ -1831,8 +1831,8 @@ public:
         ENSURE_NOT_DELETED
         ENSURE_NOT_FROZEN
         if (!--RefCount_) {
-            Result.Reset();
-            WorldLinks.reset();
+            Result_.Reset();
+            WorldLinks_.reset();
             Children_.clear();
             Constraints_.Clear();
             MarkDead();
@@ -1981,52 +1981,52 @@ public:
 
     const TConstraintNode* GetConstraint(TStringBuf name) const {
         ENSURE_NOT_DELETED
-        Y_ENSURE(static_cast<EState>(State) >= EState::ConstrComplete);
+        Y_ENSURE(static_cast<EState>(State_) >= EState::ConstrComplete);
         return Constraints_.GetConstraint(name);
     }
 
     template <class TConstraintType>
     const TConstraintType* GetConstraint() const {
         ENSURE_NOT_DELETED
-        Y_ENSURE(static_cast<EState>(State) >= EState::ConstrComplete);
+        Y_ENSURE(static_cast<EState>(State_) >= EState::ConstrComplete);
         return Constraints_.GetConstraint<TConstraintType>();
     }
 
     const TConstraintNode::TListType& GetAllConstraints() const {
         ENSURE_NOT_DELETED
-        Y_ENSURE(static_cast<EState>(State) >= EState::ConstrComplete);
+        Y_ENSURE(static_cast<EState>(State_) >= EState::ConstrComplete);
         return Constraints_.GetAllConstraints();
     }
 
     const TConstraintSet& GetConstraintSet() const {
         ENSURE_NOT_DELETED
-        Y_ENSURE(static_cast<EState>(State) >= EState::ConstrComplete);
+        Y_ENSURE(static_cast<EState>(State_) >= EState::ConstrComplete);
         return Constraints_;
     }
 
     void AddConstraint(const TConstraintNode* node) {
         ENSURE_NOT_DELETED
         ENSURE_NOT_FROZEN
-        Y_ENSURE(static_cast<EState>(State) >= EState::TypeComplete);
-        Y_ENSURE(static_cast<EState>(State) < EState::ExecutionRequired);
+        Y_ENSURE(static_cast<EState>(State_) >= EState::TypeComplete);
+        Y_ENSURE(static_cast<EState>(State_) < EState::ExecutionRequired);
         Constraints_.AddConstraint(node);
-        State = EState::ConstrComplete;
+        State_ = EState::ConstrComplete;
     }
 
     void CopyConstraints(const TExprNode& node) {
         ENSURE_NOT_DELETED
         ENSURE_NOT_FROZEN
-        Y_ENSURE(static_cast<EState>(State) >= EState::TypeComplete);
+        Y_ENSURE(static_cast<EState>(State_) >= EState::TypeComplete);
         Constraints_ = node.Constraints_;
-        State = EState::ConstrComplete;
+        State_ = EState::ConstrComplete;
     }
 
     void SetConstraints(const TConstraintSet& constraints) {
         ENSURE_NOT_DELETED
         ENSURE_NOT_FROZEN
-        Y_ENSURE(static_cast<EState>(State) >= EState::TypeComplete);
+        Y_ENSURE(static_cast<EState>(State_) >= EState::TypeComplete);
         Constraints_ = constraints;
-        State = EState::ConstrComplete;
+        State_ = EState::ConstrComplete;
     }
 
     static TPtr NewAtom(ui64 uniqueId, TPositionHandle pos, const TStringBuf& content, ui32 flags) {
@@ -2108,7 +2108,7 @@ public:
 
     void SetTypeAnn(const TTypeAnnotationNode* typeAnn) {
         TypeAnnotation_ = typeAnn;
-        State = TypeAnnotation_ ? EState::TypeComplete : EState::Initial;
+        State_ = TypeAnnotation_ ? EState::TypeComplete : EState::Initial;
     }
 
     const TTypeAnnotationNode* GetTypeAnn() const {
@@ -2116,93 +2116,93 @@ public:
     }
 
     EState GetState() const {
-        return State;
+        return State_;
     }
 
     void SetState(EState state) {
-        State = state;
+        State_ = state;
     }
 
     ui32 GetArgIndex() const {
         YQL_ENSURE(Type() == EType::Argument);
-        return ArgIndex;
+        return ArgIndex_;
     }
 
     void SetArgIndex(ui32 argIndex) {
         YQL_ENSURE(Type() == EType::Argument);
         YQL_ENSURE(argIndex <= Max<ui16>());
-        ArgIndex = (ui16)argIndex;
+        ArgIndex_ = (ui16)argIndex;
     }
 
     ui64 GetHash() const {
-        Y_DEBUG_ABORT_UNLESS(HashAbove == HashBelow);
-        return HashAbove;
+        Y_DEBUG_ABORT_UNLESS(HashAbove_ == HashBelow_);
+        return HashAbove_;
     }
 
     void SetHash(ui64 hash) {
-        HashAbove = HashBelow = hash;
+        HashAbove_ = HashBelow_ = hash;
     }
 
     ui64 GetHashAbove() const {
-        return HashAbove;
+        return HashAbove_;
     }
 
     void SetHashAbove(ui64 hash) {
-        HashAbove = hash;
+        HashAbove_ = hash;
     }
 
     ui64 GetHashBelow() const {
-        return HashBelow;
+        return HashBelow_;
     }
 
     void SetHashBelow(ui64 hash) {
-        HashBelow = hash;
+        HashBelow_ = hash;
     }
 
     ui64 GetBloom() const {
-        return Bloom;
+        return Bloom_;
     }
 
     void SetBloom(ui64 bloom) {
-        Bloom = bloom;
+        Bloom_ = bloom;
     }
 
     // return pair of outer and inner lambda.
     std::optional<std::pair<const TExprNode*, const TExprNode*>> GetDependencyScope() const {
-        if (HasLambdaScope) {
-            return std::make_pair(OuterLambda, InnerLambda);
+        if (HasLambdaScope_) {
+            return std::make_pair(OuterLambda_, InnerLambda_);
         }
         return std::nullopt;
     }
 
     void SetDependencyScope(const TExprNode* outerLambda, const TExprNode* innerLambda) {
         Y_DEBUG_ABORT_UNLESS(outerLambda == innerLambda || outerLambda->GetLambdaLevel() < innerLambda->GetLambdaLevel(), "Wrong scope of closures.");
-        HasLambdaScope = 1;
-        OuterLambda = outerLambda;
-        InnerLambda = innerLambda;
+        HasLambdaScope_ = 1;
+        OuterLambda_ = outerLambda;
+        InnerLambda_ = innerLambda;
     }
 
-    ui16 GetLambdaLevel() const { return LambdaLevel; }
-    void SetLambdaLevel(ui16 lambdaLevel) { LambdaLevel = lambdaLevel; }
+    ui16 GetLambdaLevel() const { return LambdaLevel_; }
+    void SetLambdaLevel(ui16 lambdaLevel) { LambdaLevel_ = lambdaLevel; }
 
     bool IsUsedInDependsOn() const {
         YQL_ENSURE(Type() == EType::Argument);
-        return UsedInDependsOn;
+        return UsedInDependsOn_;
     }
 
     void SetUsedInDependsOn() {
         YQL_ENSURE(Type() == EType::Argument);
-        UsedInDependsOn = 1;
+        UsedInDependsOn_ = 1;
     }
 
     void SetUnorderedChildren() {
         YQL_ENSURE(Type() == EType::List || Type() == EType::Callable);
-        UnordChildren = 1;
+        UnordChildren_ = 1;
     }
 
     bool UnorderedChildren() const {
         YQL_ENSURE(Type() == EType::List || Type() == EType::Callable);
-        return bool(UnordChildren);
+        return bool(UnordChildren_);
     }
 
     ~TExprNode() {
@@ -2229,16 +2229,16 @@ private:
         , Content_(content)
         , UniqueId_(uniqueId)
         , Position_(position)
-        , ContentSize(contentSize)
+        , ContentSize_(contentSize)
         , Type_(type)
         , Flags_(flags)
         , ExprFlags_(TExprFlags::Default)
-        , State(EState::Initial)
-        , HasLambdaScope(0)
-        , UsedInDependsOn(0)
-        , UnordChildren(0)
-        , ShallBeDisclosed(0)
-        , LiteralList(0)
+        , State_(EState::Initial)
+        , HasLambdaScope_(0)
+        , UsedInDependsOn_(0)
+        , UnordChildren_(0)
+        , ShallBeDisclosed_(0)
+        , LiteralList_(0)
     {}
 
     TExprNode(const TExprNode&) = delete;
@@ -2263,7 +2263,7 @@ private:
     }
 
     TStringBuf ContentUnchecked() const {
-        return TStringBuf(Content_, ContentSize);
+        return TStringBuf(Content_, ContentSize_);
     }
 
     TListType Children_;
@@ -2271,43 +2271,43 @@ private:
 
     const char* Content_ = nullptr;
 
-    const TExprNode* OuterLambda = nullptr;
-    const TExprNode* InnerLambda = nullptr;
+    const TExprNode* OuterLambda_ = nullptr;
+    const TExprNode* InnerLambda_ = nullptr;
 
-    TPtr Result;
+    TPtr Result_;
 
-    std::shared_ptr<TListType> WorldLinks;
+    std::shared_ptr<TListType> WorldLinks_;
 
-    ui64 HashAbove = 0ULL;
-    ui64 HashBelow = 0ULL;
-    ui64 Bloom = 0ULL;
+    ui64 HashAbove_ = 0ULL;
+    ui64 HashBelow_ = 0ULL;
+    ui64 Bloom_ = 0ULL;
 
     const ui64 UniqueId_;
     const TTypeAnnotationNode* TypeAnnotation_ = nullptr;
 
     const TPositionHandle Position_;
     ui32 RefCount_ = 0U;
-    const ui32 ContentSize;
+    const ui32 ContentSize_;
 
-    ui16 ArgIndex = ui16(-1);
-    ui16 LambdaLevel = 0; // filled together with OuterLambda
-    ui16 IntermediateHashesCount = 0;
+    ui16 ArgIndex_ = ui16(-1);
+    ui16 LambdaLevel_ = 0; // filled together with OuterLambda
+    ui16 IntermediateHashesCount_ = 0;
 
     static_assert(TypeMask <= 7, "EType wont fit in 3 bits, increase Type_ bitfield size");
     static_assert(TNodeFlags::FlagsMask <= 7, "TNodeFlags wont fit in 3 bits, increase Flags_ bitfield size");
     static_assert(TExprFlags::FlagsMask <= 3, "TExprFlags wont fit in 2 bits, increase ExprFlags_ bitfield size");
     static_assert(int(EState::Last) <= 16, "EState wont fit in 4 bits, increase State bitfield size");
     struct {
-        ui8 Type_           : 3;
-        ui8 Flags_          : 3;
-        ui8 ExprFlags_      : 2;
-
-        EState State        : 4;
-        ui8 HasLambdaScope  : 1;
-        ui8 UsedInDependsOn : 1;
-        ui8 UnordChildren   : 1;
-        ui8 ShallBeDisclosed: 1;
-        ui8 LiteralList     : 1;
+        ui8 Type_           : 3; // NOLINT(readability-identifier-naming)
+        ui8 Flags_          : 3; // NOLINT(readability-identifier-naming)
+        ui8 ExprFlags_      : 2; // NOLINT(readability-identifier-naming)
+
+        EState State_         : 4; // NOLINT(readability-identifier-naming)
+        ui8 HasLambdaScope_   : 1; // NOLINT(readability-identifier-naming)
+        ui8 UsedInDependsOn_  : 1; // NOLINT(readability-identifier-naming)
+        ui8 UnordChildren_    : 1; // NOLINT(readability-identifier-naming)
+        ui8 ShallBeDisclosed_ : 1; // NOLINT(readability-identifier-naming)
+        ui8 LiteralList_      : 1; // NOLINT(readability-identifier-naming)
     };
 };
 
@@ -2580,17 +2580,17 @@ struct TExprContext : private TNonCopyable {
         TFreezeGuard& operator=(const TFreezeGuard&) = delete;
 
         TFreezeGuard(TExprContext& ctx)
-            : Ctx(ctx)
+            : Ctx_(ctx)
         {
-            Ctx.Freeze();
+            Ctx_.Freeze();
         }
 
         ~TFreezeGuard() {
-            Ctx.UnFreeze();
+            Ctx_.UnFreeze();
         }
 
     private:
-        TExprContext& Ctx;
+        TExprContext& Ctx_;
     };
 
     TIssueManager IssueManager;
@@ -2840,8 +2840,8 @@ private:
     bool IsEqual(TPositionHandle a, TPositionHandle b) const;
     size_t GetHash(TPositionHandle p) const;
 
-    std::unordered_set<TPositionHandle, TPositionHandleHasher, TPositionHandleEqualPred> PositionSet;
-    std::deque<TPosition> Positions;
+    std::unordered_set<TPositionHandle, TPositionHandleHasher, TPositionHandleEqualPred> PositionSet_;
+    std::deque<TPosition> Positions_;
 };
 
 template <typename T, typename... Args>
diff --git a/yql/essentials/ast/yql_expr_builder.cpp b/yql/essentials/ast/yql_expr_builder.cpp
index 5468cadd2cc..f459937be45 100644
--- a/yql/essentials/ast/yql_expr_builder.cpp
+++ b/yql/essentials/ast/yql_expr_builder.cpp
@@ -4,292 +4,292 @@
 namespace NYql {
 
 TExprNodeBuilder::TExprNodeBuilder(TPositionHandle pos, TExprContext& ctx)
-    : Ctx(ctx)
-    , Parent(nullptr)
-    , ParentReplacer(nullptr)
-    , Container(nullptr)
-    , Pos(pos)
-    , CurrentNode(nullptr)
+    : Ctx_(ctx)
+    , Parent_(nullptr)
+    , ParentReplacer_(nullptr)
+    , Container_(nullptr)
+    , Pos_(pos)
+    , CurrentNode_(nullptr)
 {}
 
 TExprNodeBuilder::TExprNodeBuilder(TPositionHandle pos, TExprContext& ctx, ExtArgsFuncType extArgsFunc)
-    : Ctx(ctx)
-    , Parent(nullptr)
-    , ParentReplacer(nullptr)
-    , Container(nullptr)
-    , Pos(pos)
-    , CurrentNode(nullptr)
-    , ExtArgsFunc(extArgsFunc)
+    : Ctx_(ctx)
+    , Parent_(nullptr)
+    , ParentReplacer_(nullptr)
+    , Container_(nullptr)
+    , Pos_(pos)
+    , CurrentNode_(nullptr)
+    , ExtArgsFunc_(extArgsFunc)
 {}
 
 TExprNodeBuilder::TExprNodeBuilder(TPositionHandle pos, TExprNodeBuilder* parent, const TExprNode::TPtr& container)
-    : Ctx(parent->Ctx)
-    , Parent(parent)
-    , ParentReplacer(nullptr)
-    , Container(std::move(container))
-    , Pos(pos)
-    , CurrentNode(nullptr)
+    : Ctx_(parent->Ctx_)
+    , Parent_(parent)
+    , ParentReplacer_(nullptr)
+    , Container_(std::move(container))
+    , Pos_(pos)
+    , CurrentNode_(nullptr)
 {
-    if (Parent) {
-        ExtArgsFunc = Parent->ExtArgsFunc;
+    if (Parent_) {
+        ExtArgsFunc_ = Parent_->ExtArgsFunc_;
     }
 }
 
 TExprNodeBuilder::TExprNodeBuilder(TPositionHandle pos, TExprNodeReplaceBuilder* parentReplacer)
-    : Ctx(parentReplacer->Owner->Ctx)
-    , Parent(nullptr)
-    , ParentReplacer(parentReplacer)
-    , Container(nullptr)
-    , Pos(pos)
-    , CurrentNode(nullptr)
+    : Ctx_(parentReplacer->Owner_->Ctx_)
+    , Parent_(nullptr)
+    , ParentReplacer_(parentReplacer)
+    , Container_(nullptr)
+    , Pos_(pos)
+    , CurrentNode_(nullptr)
 {
 }
 
 TExprNode::TPtr TExprNodeBuilder::Build() {
-    Y_ENSURE(CurrentNode, "No current node");
-    Y_ENSURE(!Parent, "Build is allowed only on top level");
-    if (CurrentNode->Type() == TExprNode::Lambda) {
-        Y_ENSURE(CurrentNode->ChildrenSize() > 0U, "Lambda is not complete");
+    Y_ENSURE(CurrentNode_, "No current node");
+    Y_ENSURE(!Parent_, "Build is allowed only on top level");
+    if (CurrentNode_->Type() == TExprNode::Lambda) {
+        Y_ENSURE(CurrentNode_->ChildrenSize() > 0U, "Lambda is not complete");
     }
 
-    return CurrentNode;
+    return CurrentNode_;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Seal() {
-    Y_ENSURE(Parent, "Seal is allowed only on non-top level");
-    if (Container->Type() == TExprNode::Lambda) {
-        if (CurrentNode) {
-            Y_ENSURE(Container->ChildrenSize() == 1, "Lambda is already complete.");
-            Container->Children_.emplace_back(std::move(CurrentNode));
+    Y_ENSURE(Parent_, "Seal is allowed only on non-top level");
+    if (Container_->Type() == TExprNode::Lambda) {
+        if (CurrentNode_) {
+            Y_ENSURE(Container_->ChildrenSize() == 1, "Lambda is already complete.");
+            Container_->Children_.emplace_back(std::move(CurrentNode_));
         } else {
-            Y_ENSURE(Container->ChildrenSize() > 0U, "Lambda isn't complete.");
+            Y_ENSURE(Container_->ChildrenSize() > 0U, "Lambda isn't complete.");
         }
     }
 
-    return *Parent;
+    return *Parent_;
 }
 
 TExprNodeReplaceBuilder& TExprNodeBuilder::Done() {
-    Y_ENSURE(ParentReplacer, "Done is allowed only if parent is a replacer");
-    Y_ENSURE(CurrentNode, "No current node");
-    for (auto& body : ParentReplacer->Body)
-        body = Ctx.ReplaceNode(std::move(body), ParentReplacer->CurrentNode ? *ParentReplacer->CurrentNode : *ParentReplacer->Args->Child(ParentReplacer->CurrentIndex), CurrentNode);
-    return *ParentReplacer;
+    Y_ENSURE(ParentReplacer_, "Done is allowed only if parent is a replacer");
+    Y_ENSURE(CurrentNode_, "No current node");
+    for (auto& body : ParentReplacer_->Body_)
+        body = Ctx_.ReplaceNode(std::move(body), ParentReplacer_->CurrentNode_ ? *ParentReplacer_->CurrentNode_ : *ParentReplacer_->Args_->Child(ParentReplacer_->CurrentIndex_), CurrentNode_);
+    return *ParentReplacer_;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Atom(ui32 index, TPositionHandle pos, const TStringBuf& content, ui32 flags) {
-    Y_ENSURE(Container && !Container->IsLambda(), "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index,
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_ && !Container_->IsLambda(), "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index,
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
-    auto child = Ctx.NewAtom(pos, content, flags);
-    Container->Children_.push_back(child);
+    auto child = Ctx_.NewAtom(pos, content, flags);
+    Container_->Children_.push_back(child);
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Atom(TPositionHandle pos, const TStringBuf& content, ui32 flags) {
-    Y_ENSURE(!Container || Container->IsLambda(), "No container expected");
-    Y_ENSURE(!CurrentNode, "Node is already build");
-    CurrentNode = Ctx.NewAtom(pos, content, flags);
+    Y_ENSURE(!Container_ || Container_->IsLambda(), "No container expected");
+    Y_ENSURE(!CurrentNode_, "Node is already build");
+    CurrentNode_ = Ctx_.NewAtom(pos, content, flags);
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Atom(ui32 index, const TStringBuf& content, ui32 flags) {
-    return Atom(index, Pos, content, flags);
+    return Atom(index, Pos_, content, flags);
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Atom(const TStringBuf& content, ui32 flags) {
-    return Atom(Pos, content, flags);
+    return Atom(Pos_, content, flags);
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Atom(ui32 index, ui32 literalIndexValue) {
-    return Atom(index, Pos, Ctx.GetIndexAsString(literalIndexValue), TNodeFlags::Default);
+    return Atom(index, Pos_, Ctx_.GetIndexAsString(literalIndexValue), TNodeFlags::Default);
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Atom(ui32 literalIndexValue) {
-    return Atom(Pos, Ctx.GetIndexAsString(literalIndexValue), TNodeFlags::Default);
+    return Atom(Pos_, Ctx_.GetIndexAsString(literalIndexValue), TNodeFlags::Default);
 }
 
 TExprNodeBuilder TExprNodeBuilder::List(ui32 index, TPositionHandle pos) {
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index + (Container_->IsLambda() ? 1U : 0U),
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
-    const auto child = Ctx.NewList(pos, {});
-    Container->Children_.push_back(child);
+    const auto child = Ctx_.NewList(pos, {});
+    Container_->Children_.push_back(child);
     return TExprNodeBuilder(pos, this, child);
 }
 
 TExprNodeBuilder TExprNodeBuilder::List(TPositionHandle pos) {
-    Y_ENSURE(!Container || Container->Type() == TExprNode::Lambda, "No container expected");
-    Y_ENSURE(!CurrentNode, "Node is already build");
-    CurrentNode = Ctx.NewList(pos, {});
-    return TExprNodeBuilder(pos, this, CurrentNode);
+    Y_ENSURE(!Container_ || Container_->Type() == TExprNode::Lambda, "No container expected");
+    Y_ENSURE(!CurrentNode_, "Node is already build");
+    CurrentNode_ = Ctx_.NewList(pos, {});
+    return TExprNodeBuilder(pos, this, CurrentNode_);
 }
 
 TExprNodeBuilder TExprNodeBuilder::List(ui32 index) {
-    return List(index, Pos);
+    return List(index, Pos_);
 }
 
 TExprNodeBuilder TExprNodeBuilder::List() {
-    return List(Pos);
+    return List(Pos_);
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Add(ui32 index, const TExprNode::TPtr& child) {
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index + (Container_->IsLambda() ? 1U : 0U),
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
     Y_ENSURE(child, "child should not be nullptr");
-    Container->Children_.push_back(child);
+    Container_->Children_.push_back(child);
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Add(ui32 index, TExprNode::TPtr&& child) {
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index + (Container_->IsLambda() ? 1U : 0U),
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
     Y_ENSURE(child, "child should not be nullptr");
-    Container->Children_.push_back(std::move(child));
+    Container_->Children_.push_back(std::move(child));
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Add(TExprNode::TListType&& children) {
-    Y_ENSURE(Container && Container->Type() != TExprNode::Lambda, "Container expected");
-    Y_ENSURE(Container->Children_.empty(), "container should be empty");
-    Container->Children_ = std::move(children);
+    Y_ENSURE(Container_ && Container_->Type() != TExprNode::Lambda, "Container expected");
+    Y_ENSURE(Container_->Children_.empty(), "container should be empty");
+    Container_->Children_ = std::move(children);
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Set(TExprNode::TPtr&& body) {
-    Y_ENSURE(Container && Container->Type() == TExprNode::Lambda, "Lambda expected");
-    Y_ENSURE(!CurrentNode, "Lambda already has a body");
-    CurrentNode = std::move(body);
+    Y_ENSURE(Container_ && Container_->Type() == TExprNode::Lambda, "Lambda expected");
+    Y_ENSURE(!CurrentNode_, "Lambda already has a body");
+    CurrentNode_ = std::move(body);
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Set(const TExprNode::TPtr& body) {
-    Y_ENSURE(Container && Container->Type() == TExprNode::Lambda, "Lambda expected");
-    Y_ENSURE(!CurrentNode, "Lambda already has a body");
-    CurrentNode = body;
+    Y_ENSURE(Container_ && Container_->Type() == TExprNode::Lambda, "Lambda expected");
+    Y_ENSURE(!CurrentNode_, "Lambda already has a body");
+    CurrentNode_ = body;
     return *this;
 }
 
 TExprNodeBuilder TExprNodeBuilder::Callable(ui32 index, TPositionHandle pos, const TStringBuf& content) {
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index + (Container_->IsLambda() ? 1U : 0U),
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
-    auto child = Ctx.NewCallable(pos, content, {});
-    Container->Children_.push_back(child);
+    auto child = Ctx_.NewCallable(pos, content, {});
+    Container_->Children_.push_back(child);
     return TExprNodeBuilder(pos, this, child);
 }
 
 TExprNodeBuilder TExprNodeBuilder::Callable(TPositionHandle pos, const TStringBuf& content) {
-    Y_ENSURE(!Container || Container->Type() == TExprNode::Lambda, "No container expected");
-    Y_ENSURE(!CurrentNode, "Node is already build");
-    CurrentNode = Ctx.NewCallable(pos, content, {});
-    return TExprNodeBuilder(pos, this, CurrentNode);
+    Y_ENSURE(!Container_ || Container_->Type() == TExprNode::Lambda, "No container expected");
+    Y_ENSURE(!CurrentNode_, "Node is already build");
+    CurrentNode_ = Ctx_.NewCallable(pos, content, {});
+    return TExprNodeBuilder(pos, this, CurrentNode_);
 }
 
 TExprNodeBuilder TExprNodeBuilder::Callable(ui32 index, const TStringBuf& content) {
-    return Callable(index, Pos, content);
+    return Callable(index, Pos_, content);
 }
 
 TExprNodeBuilder TExprNodeBuilder::Callable(const TStringBuf& content) {
-    return Callable(Pos, content);
+    return Callable(Pos_, content);
 }
 
 TExprNodeBuilder& TExprNodeBuilder::World(ui32 index, TPositionHandle pos) {
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index + (Container_->IsLambda() ? 1U : 0U),
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
-    auto child = Ctx.NewWorld(pos);
-    Container->Children_.push_back(child);
+    auto child = Ctx_.NewWorld(pos);
+    Container_->Children_.push_back(child);
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::World(TPositionHandle pos) {
-    Y_ENSURE(!Container, "No container expected");
-    Y_ENSURE(!CurrentNode, "Node is already build");
-    CurrentNode = Ctx.NewWorld(pos);
+    Y_ENSURE(!Container_, "No container expected");
+    Y_ENSURE(!CurrentNode_, "Node is already build");
+    CurrentNode_ = Ctx_.NewWorld(pos);
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::World(ui32 index) {
-    return World(index, Pos);
+    return World(index, Pos_);
 }
 
 TExprNodeBuilder& TExprNodeBuilder::World() {
-    return World(Pos);
+    return World(Pos_);
 }
 
 TExprNodeBuilder TExprNodeBuilder::Lambda(ui32 index, TPositionHandle pos) {
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index + (Container_->IsLambda() ? 1U : 0U),
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
-    auto child = Ctx.NewLambda(pos, Ctx.NewArguments(pos, {}), nullptr);
-    Container->Children_.push_back(child);
+    auto child = Ctx_.NewLambda(pos, Ctx_.NewArguments(pos, {}), nullptr);
+    Container_->Children_.push_back(child);
     return TExprNodeBuilder(pos, this, child);
 }
 
 TExprNodeBuilder TExprNodeBuilder::Lambda(TPositionHandle pos) {
-    Y_ENSURE(!Container || Container->Type() == TExprNode::Lambda, "No container expected");
-    Y_ENSURE(!CurrentNode, "Node is already build");
-    CurrentNode = Ctx.NewLambda(pos, Ctx.NewArguments(pos, {}), nullptr);
-    return TExprNodeBuilder(pos, this, CurrentNode);
+    Y_ENSURE(!Container_ || Container_->Type() == TExprNode::Lambda, "No container expected");
+    Y_ENSURE(!CurrentNode_, "Node is already build");
+    CurrentNode_ = Ctx_.NewLambda(pos, Ctx_.NewArguments(pos, {}), nullptr);
+    return TExprNodeBuilder(pos, this, CurrentNode_);
 }
 
 TExprNodeBuilder TExprNodeBuilder::Lambda(ui32 index) {
-    return Lambda(index, Pos);
+    return Lambda(index, Pos_);
 }
 
 TExprNodeBuilder TExprNodeBuilder::Lambda() {
-    return Lambda(Pos);
+    return Lambda(Pos_);
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Param(TPositionHandle pos, const TStringBuf& name) {
     Y_ENSURE(!name.empty(), "Empty parameter name is not allowed");
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->Type() == TExprNode::Lambda, "Container must be a lambda");
-    Y_ENSURE(!CurrentNode, "Lambda already has a body");
-    for (auto arg : Container->Head().Children()) {
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->Type() == TExprNode::Lambda, "Container must be a lambda");
+    Y_ENSURE(!CurrentNode_, "Lambda already has a body");
+    for (auto arg : Container_->Head().Children()) {
         Y_ENSURE(arg->Content() != name, "Duplicate of lambda param name: " << name);
     }
 
-    Container->Head().Children_.push_back(Ctx.NewArgument(pos, name));
+    Container_->Head().Children_.push_back(Ctx_.NewArgument(pos, name));
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Param(const TStringBuf& name) {
-    return Param(Pos, name);
+    return Param(Pos_, name);
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Params(const TStringBuf& name, ui32 width) {
     Y_ENSURE(!name.empty(), "Empty parameter name is not allowed");
     for (ui32 i = 0U; i < width; ++i)
-        Param(Pos, TString(name) += ToString(i));
+        Param(Pos_, TString(name) += ToString(i));
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Arg(ui32 index, const TStringBuf& name) {
     Y_ENSURE(!name.empty(), "Empty parameter name is not allowed");
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index + (Container_->IsLambda() ? 1U : 0U),
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
     auto arg = FindArgument(name);
-    Container->Children_.push_back(arg);
+    Container_->Children_.push_back(arg);
     return *this;
 }
 
 TExprNodeBuilder& TExprNodeBuilder::Arg(const TStringBuf& name) {
-    Y_ENSURE(!Container || Container->Type() == TExprNode::Lambda, "No container expected");
-    Y_ENSURE(!CurrentNode, "Node is already build");
-    CurrentNode = FindArgument(name);
+    Y_ENSURE(!Container_ || Container_->Type() == TExprNode::Lambda, "No container expected");
+    Y_ENSURE(!CurrentNode_, "Node is already build");
+    CurrentNode_ = FindArgument(name);
     return *this;
 }
 
@@ -305,9 +305,9 @@ TExprNodeBuilder& TExprNodeBuilder::Arg(const TStringBuf& name, ui32 toIndex) {
 
 TExprNodeBuilder& TExprNodeBuilder::Arg(const TExprNodePtr& arg) {
     Y_ENSURE(arg->Type() == TExprNode::Argument, "Argument expected");
-    Y_ENSURE(!Container || Container->Type() == TExprNode::Lambda, "No container expected");
-    Y_ENSURE(!CurrentNode, "Node is already build");
-    CurrentNode = arg;
+    Y_ENSURE(!Container_ || Container_->Type() == TExprNode::Lambda, "No container expected");
+    Y_ENSURE(!CurrentNode_, "Node is already build");
+    CurrentNode_ = arg;
     return *this;
 }
 
@@ -326,13 +326,13 @@ TExprNodeBuilder& TExprNodeBuilder::Args(const TStringBuf& name, ui32 toIndex) {
 }
 
 TExprNode::TPtr TExprNodeBuilder::FindArgument(const TStringBuf& name) {
-    for (auto builder = this; builder; builder = builder->Parent) {
-        while (builder->ParentReplacer) {
-            builder = builder->ParentReplacer->Owner;
+    for (auto builder = this; builder; builder = builder->Parent_) {
+        while (builder->ParentReplacer_) {
+            builder = builder->ParentReplacer_->Owner_;
         }
 
-        if (builder->Container && builder->Container->IsLambda()) {
-            for (const auto& arg : builder->Container->Head().Children()) {
+        if (builder->Container_ && builder->Container_->IsLambda()) {
+            for (const auto& arg : builder->Container_->Head().Children()) {
                 if (arg->Content() == name) {
                     return arg;
                 }
@@ -340,8 +340,8 @@ TExprNode::TPtr TExprNodeBuilder::FindArgument(const TStringBuf& name) {
         }
     }
 
-    if (ExtArgsFunc) {
-        if (const auto arg = ExtArgsFunc(name)) {
+    if (ExtArgsFunc_) {
+        if (const auto arg = ExtArgsFunc_(name)) {
             return arg;
         }
     }
@@ -350,17 +350,17 @@ TExprNode::TPtr TExprNodeBuilder::FindArgument(const TStringBuf& name) {
 }
 
 TExprNodeReplaceBuilder TExprNodeBuilder::Apply(ui32 index, const TExprNode& lambda) {
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index + (Container_->IsLambda() ? 1U : 0U),
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
-    return TExprNodeReplaceBuilder(this, Container, lambda.HeadPtr(), GetLambdaBody(lambda));
+    return TExprNodeReplaceBuilder(this, Container_, lambda.HeadPtr(), GetLambdaBody(lambda));
 }
 
 TExprNodeReplaceBuilder TExprNodeBuilder::Apply(const TExprNode& lambda) {
-    Y_ENSURE(!Container || Container->Type() == TExprNode::Lambda, "No container expected");
-    Y_ENSURE(!CurrentNode, "Node is already build");
-    return TExprNodeReplaceBuilder(this, Container, lambda.HeadPtr(), GetLambdaBody(lambda));
+    Y_ENSURE(!Container_ || Container_->Type() == TExprNode::Lambda, "No container expected");
+    Y_ENSURE(!CurrentNode_, "Node is already build");
+    return TExprNodeReplaceBuilder(this, Container_, lambda.HeadPtr(), GetLambdaBody(lambda));
 }
 
 TExprNodeReplaceBuilder TExprNodeBuilder::Apply(ui32 index, const TExprNode::TPtr& lambda) {
@@ -372,56 +372,56 @@ TExprNodeReplaceBuilder TExprNodeBuilder::Apply(const TExprNode::TPtr& lambda) {
 }
 
 TExprNodeReplaceBuilder TExprNodeBuilder::ApplyPartial(ui32 index, TExprNode::TPtr args, TExprNode::TPtr body) {
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index + (Container_->IsLambda() ? 1U : 0U),
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
     Y_ENSURE(!args || args->IsArguments());
-    return TExprNodeReplaceBuilder(this, Container, std::move(args), std::move(body));
+    return TExprNodeReplaceBuilder(this, Container_, std::move(args), std::move(body));
 }
 
 TExprNodeReplaceBuilder TExprNodeBuilder::ApplyPartial(ui32 index, TExprNode::TPtr args, TExprNode::TListType body) {
-    Y_ENSURE(Container, "Container expected");
-    Y_ENSURE(Container->ChildrenSize() == index + (Container->IsLambda() ? 1U : 0U),
-        "Container position mismatch, expected: " << Container->ChildrenSize() <<
+    Y_ENSURE(Container_, "Container expected");
+    Y_ENSURE(Container_->ChildrenSize() == index + (Container_->IsLambda() ? 1U : 0U),
+        "Container position mismatch, expected: " << Container_->ChildrenSize() <<
         ", actual: " << index);
     Y_ENSURE(!args || args->IsArguments());
-    return TExprNodeReplaceBuilder(this, Container, std::move(args), std::move(body));
+    return TExprNodeReplaceBuilder(this, Container_, std::move(args), std::move(body));
 }
 
 TExprNodeReplaceBuilder TExprNodeBuilder::ApplyPartial(TExprNode::TPtr args, TExprNode::TPtr body) {
-    Y_ENSURE(!Container || Container->Type() == TExprNode::Lambda, "No container expected");
-    Y_ENSURE(!CurrentNode, "Node is already build");
+    Y_ENSURE(!Container_ || Container_->Type() == TExprNode::Lambda, "No container expected");
+    Y_ENSURE(!CurrentNode_, "Node is already build");
     Y_ENSURE(!args || args->IsArguments());
-    return TExprNodeReplaceBuilder(this, Container, std::move(args), std::move(body));
+    return TExprNodeReplaceBuilder(this, Container_, std::move(args), std::move(body));
 }
 
 TExprNodeReplaceBuilder TExprNodeBuilder::ApplyPartial(TExprNode::TPtr args, TExprNode::TListType body) {
-    Y_ENSURE(!Container || Container->Type() == TExprNode::Lambda, "No container expected");
-    Y_ENSURE(!CurrentNode, "Node is already build");
+    Y_ENSURE(!Container_ || Container_->Type() == TExprNode::Lambda, "No container expected");
+    Y_ENSURE(!CurrentNode_, "Node is already build");
     Y_ENSURE(!args || args->IsArguments());
-    return TExprNodeReplaceBuilder(this, Container, std::move(args), std::move(body));
+    return TExprNodeReplaceBuilder(this, Container_, std::move(args), std::move(body));
 }
 
 TExprNodeReplaceBuilder::TExprNodeReplaceBuilder(TExprNodeBuilder* owner, TExprNode::TPtr container,
     TExprNode::TPtr&& args, TExprNode::TPtr&& body)
-    : Owner(owner)
-    , Container(std::move(container))
-    , Args(std::move(args))
-    , Body({std::move(body)})
-    , CurrentIndex(0)
-    , CurrentNode(nullptr)
+    : Owner_(owner)
+    , Container_(std::move(container))
+    , Args_(std::move(args))
+    , Body_({std::move(body)})
+    , CurrentIndex_(0)
+    , CurrentNode_(nullptr)
 {
 }
 
 TExprNodeReplaceBuilder::TExprNodeReplaceBuilder(TExprNodeBuilder* owner, TExprNode::TPtr container,
     TExprNode::TPtr&& args, TExprNode::TListType&& body)
-    : Owner(owner)
-    , Container(std::move(container))
-    , Args(std::move(args))
-    , Body(std::move(body))
-    , CurrentIndex(0)
-    , CurrentNode(nullptr)
+    : Owner_(owner)
+    , Container_(std::move(container))
+    , Args_(std::move(args))
+    , Body_(std::move(body))
+    , CurrentIndex_(0)
+    , CurrentNode_(nullptr)
 {
 }
 
@@ -434,27 +434,27 @@ TExprNodeReplaceBuilder::TExprNodeReplaceBuilder(TExprNodeBuilder* owner, TExprN
 
 TExprNodeReplaceBuilder& TExprNodeReplaceBuilder::With(
     ui32 argIndex, const TStringBuf& toName) {
-    Y_ENSURE(Args, "No arguments");
-    Y_ENSURE(argIndex < Args->ChildrenSize(), "Wrong argument index");
-    Body = Owner->Ctx.ReplaceNodes(std::move(Body), {{Args->Child(argIndex), Owner->FindArgument(toName)}});
+    Y_ENSURE(Args_, "No arguments");
+    Y_ENSURE(argIndex < Args_->ChildrenSize(), "Wrong argument index");
+    Body_ = Owner_->Ctx_.ReplaceNodes(std::move(Body_), {{Args_->Child(argIndex), Owner_->FindArgument(toName)}});
     return *this;
 }
 
 TExprNodeReplaceBuilder& TExprNodeReplaceBuilder::With(
     ui32 argIndex, TExprNode::TPtr toNode) {
-    Y_ENSURE(Args, "No arguments");
-    Y_ENSURE(argIndex < Args->ChildrenSize(), "Wrong argument index");
-    Body = Owner->Ctx.ReplaceNodes(std::move(Body), {{Args->Child(argIndex), std::move(toNode)}});
+    Y_ENSURE(Args_, "No arguments");
+    Y_ENSURE(argIndex < Args_->ChildrenSize(), "Wrong argument index");
+    Body_ = Owner_->Ctx_.ReplaceNodes(std::move(Body_), {{Args_->Child(argIndex), std::move(toNode)}});
     return *this;
 }
 
 TExprNodeReplaceBuilder& TExprNodeReplaceBuilder::With(const TStringBuf& toName) {
-    Y_ENSURE(Args, "No arguments");
+    Y_ENSURE(Args_, "No arguments");
     Y_ENSURE(!toName.empty(), "Empty parameter name is not allowed");
-    TNodeOnNodeOwnedMap replaces(Args->ChildrenSize());
-    for (ui32 i = 0U; i < Args->ChildrenSize(); ++i)
-        Y_ENSURE(replaces.emplace(Args->Child(i), Owner->FindArgument(TString(toName) += ToString(i))).second, "Must be uinique.");
-    Body = Owner->Ctx.ReplaceNodes(std::move(Body), replaces);
+    TNodeOnNodeOwnedMap replaces(Args_->ChildrenSize());
+    for (ui32 i = 0U; i < Args_->ChildrenSize(); ++i)
+        Y_ENSURE(replaces.emplace(Args_->Child(i), Owner_->FindArgument(TString(toName) += ToString(i))).second, "Must be uinique.");
+    Body_ = Owner_->Ctx_.ReplaceNodes(std::move(Body_), replaces);
     return *this;
 }
 
@@ -469,33 +469,33 @@ TExprNodeReplaceBuilder& TExprNodeReplaceBuilder::With(ui32 argIndex, const TStr
 }
 
 TExprNodeReplaceBuilder& TExprNodeReplaceBuilder::WithNode(const TExprNode& fromNode, TExprNode::TPtr&& toNode) {
-    Body = Owner->Ctx.ReplaceNodes(std::move(Body), {{&fromNode, std::move(toNode)}});
+    Body_ = Owner_->Ctx_.ReplaceNodes(std::move(Body_), {{&fromNode, std::move(toNode)}});
     return *this;
 }
 
 TExprNodeReplaceBuilder& TExprNodeReplaceBuilder::WithNode(const TExprNode& fromNode, const TStringBuf& toName) {
-    return WithNode(fromNode, Owner->FindArgument(toName));
+    return WithNode(fromNode, Owner_->FindArgument(toName));
 }
 
 TExprNodeBuilder TExprNodeReplaceBuilder::With(ui32 argIndex) {
-    CurrentIndex = argIndex;
-    return TExprNodeBuilder(Owner->Pos, this);
+    CurrentIndex_ = argIndex;
+    return TExprNodeBuilder(Owner_->Pos_, this);
 }
 
 TExprNodeBuilder  TExprNodeReplaceBuilder::WithNode(TExprNode::TPtr&& fromNode) {
-    CurrentNode = std::move(fromNode);
-    return TExprNodeBuilder(Owner->Pos, this);
+    CurrentNode_ = std::move(fromNode);
+    return TExprNodeBuilder(Owner_->Pos_, this);
 }
 
 TExprNodeBuilder& TExprNodeReplaceBuilder::Seal() {
-    if (Container) {
-        std::move(Body.begin(), Body.end(), std::back_inserter(Container->Children_));
+    if (Container_) {
+        std::move(Body_.begin(), Body_.end(), std::back_inserter(Container_->Children_));
     } else {
-        Y_ENSURE(1U == Body.size() && Body.front(), "Expected single node.");
-        Owner->CurrentNode = std::move(Body.front());
+        Y_ENSURE(1U == Body_.size() && Body_.front(), "Expected single node.");
+        Owner_->CurrentNode_ = std::move(Body_.front());
     }
-    Body.clear();
-    return *Owner;
+    Body_.clear();
+    return *Owner_;
 }
 
 } // namespace NYql
diff --git a/yql/essentials/ast/yql_expr_builder.h b/yql/essentials/ast/yql_expr_builder.h
index db816359eb9..18f7b1daafe 100644
--- a/yql/essentials/ast/yql_expr_builder.h
+++ b/yql/essentials/ast/yql_expr_builder.h
@@ -95,13 +95,13 @@ private:
     TExprNodePtr FindArgument(const TStringBuf& name);
 
 private:
-    TExprContext& Ctx;
-    TExprNodeBuilder* Parent;
-    TExprNodeReplaceBuilder* ParentReplacer;
-    TExprNodePtr Container;
-    TPositionHandle Pos;
-    TExprNodePtr CurrentNode;
-    ExtArgsFuncType ExtArgsFunc;
+    TExprContext& Ctx_;
+    TExprNodeBuilder* Parent_;
+    TExprNodeReplaceBuilder* ParentReplacer_;
+    TExprNodePtr Container_;
+    TPositionHandle Pos_;
+    TExprNodePtr CurrentNode_;
+    ExtArgsFuncType ExtArgsFunc_;
 };
 
 namespace NNodes {
@@ -143,13 +143,13 @@ public:
     NNodes::TNodeBuilder<TBuildAdapter, TNode> With(ui32 argIndex) {
         TBuildAdapter adapter(*this);
 
-        NNodes::TNodeBuilder<TBuildAdapter, TNode> builder(Owner->Ctx, Owner->Pos,
+        NNodes::TNodeBuilder<TBuildAdapter, TNode> builder(Owner_->Ctx_, Owner_->Pos_,
             [adapter, argIndex](const TNode& node) mutable -> TBuildAdapter& {
                 adapter.Builder = adapter.Builder.With(argIndex, node.Get());
                 return adapter;
             },
             [adapter] (const TStringBuf& argName) {
-                return adapter.Builder.Owner->FindArgument(argName);
+                return adapter.Builder.Owner_->FindArgument(argName);
             });
 
         return builder;
@@ -163,12 +163,12 @@ public:
     }
 
 private:
-    TExprNodeBuilder* Owner;
-    TExprNodePtr Container;
-    TExprNodePtr Args;
-    TExprNodeList Body;
-    ui32 CurrentIndex;
-    TExprNodePtr CurrentNode;
+    TExprNodeBuilder* Owner_;
+    TExprNodePtr Container_;
+    TExprNodePtr Args_;
+    TExprNodeList Body_;
+    ui32 CurrentIndex_;
+    TExprNodePtr CurrentNode_;
 };
 
 } // namespace NYql
diff --git a/yql/essentials/ast/yql_pos_handle.h b/yql/essentials/ast/yql_pos_handle.h
index e00cf63a78c..eecf9173868 100644
--- a/yql/essentials/ast/yql_pos_handle.h
+++ b/yql/essentials/ast/yql_pos_handle.h
@@ -7,7 +7,7 @@ namespace NYql {
 struct TPositionHandle {
     friend struct TExprContext;
 private:
-    ui32 Handle = 0; // 0 is guaranteed to represent default-constructed TPosition
+    ui32 Handle_ = 0; // 0 is guaranteed to represent default-constructed TPosition
 };
 
 }
diff --git a/yql/essentials/ast/yql_type_string.cpp b/yql/essentials/ast/yql_type_string.cpp
index 20c86034090..cfb144ce62c 100644
--- a/yql/essentials/ast/yql_type_string.cpp
+++ b/yql/essentials/ast/yql_type_string.cpp
@@ -15,7 +15,7 @@
 
 #define EXPECT_AND_SKIP_TOKEN_IMPL(token, message, result) \
     do { \
-        if (Y_LIKELY(Token == token)) { \
+        if (Y_LIKELY(Token_ == token)) { \
             GetNextToken(); \
         } else { \
             AddError(message); \
@@ -186,11 +186,11 @@ public:
     TTypeParser(
             TStringBuf str, TIssues& issues,
             TPosition position, TMemoryPool& pool)
-        : Str(str)
-        , Issues(issues)
-        , Position(position)
-        , Index(0)
-        , Pool(pool)
+        : Str_(str)
+        , Issues_(issues)
+        , Position_(position)
+        , Index_(0)
+        , Pool_(pool)
     {
         GetNextToken();
     }
@@ -208,7 +208,7 @@ private:
     TAstNode* ParseType() {
         TAstNode* type = nullptr;
 
-        switch (Token) {
+        switch (Token_) {
         case '(': return ParseCallableType();
 
         case TOKEN_STRING:
@@ -243,7 +243,7 @@ private:
         case TOKEN_TZDATE32:
         case TOKEN_TZDATETIME64:
         case TOKEN_TZTIMESTAMP64:
-            type = MakeDataType(Identifier);
+            type = MakeDataType(Identifier_);
             GetNextToken();
             break;
 
@@ -350,11 +350,11 @@ private:
             break;
 
         default:
-            if (Identifier.empty()) {
+            if (Identifier_.empty()) {
                 return AddError("Expected type");
             }
 
-            auto id = Identifier;
+            auto id = Identifier_;
             if (id.SkipPrefix("pg")) {
                 if (NPg::HasType(TString(id))) {
                     type = MakePgType(id);
@@ -368,12 +368,12 @@ private:
             }
 
             if (!type) {
-                return AddError(TString("Unknown type: '") + Identifier + "\'");
+                return AddError(TString("Unknown type: '") + Identifier_ + "\'");
             }
         }
 
         if (type) {
-            while (Token == '?') {
+            while (Token_ == '?') {
                 type = MakeOptionalType(type);
                 GetNextToken();
             }
@@ -382,15 +382,15 @@ private:
     }
 
     char LookaheadNonSpaceChar() {
-        size_t i = Index;
-        while (i < Str.size() && isspace(Str[i])) {
+        size_t i = Index_;
+        while (i < Str_.size() && isspace(Str_[i])) {
             i++;
         }
-        return (i < Str.size()) ? Str[i] : -1;
+        return (i < Str_.size()) ? Str_[i] : -1;
     }
 
     int GetNextToken() {
-        return Token = ReadNextToken();
+        return Token_ = ReadNextToken();
     }
 
     int ReadNextToken() {
@@ -399,32 +399,32 @@ private:
             Move();
         }
 
-        TokenBegin = Position;
+        TokenBegin_ = Position_;
         if (AtEnd()) {
             return TOKEN_EOF;
         }
 
         // clear last readed indentifier
-        Identifier = {};
+        Identifier_ = {};
 
         char lastChar = Get();
         if (lastChar == '_' || isalnum(lastChar)) { // identifier
-            size_t start = Index;
+            size_t start = Index_;
             while (!AtEnd()) {
                 lastChar = Get();
                 if (lastChar == '_' || isalnum(lastChar)) Move();
                 else break;
             }
 
-            Identifier = Str.SubString(start, Index - start);
-            return TokenTypeFromStr(Identifier);
+            Identifier_ = Str_.SubString(start, Index_ - start);
+            return TokenTypeFromStr(Identifier_);
         } else if (lastChar == '\'') {  // escaped identifier
             Move(); // skip '\''
             if (AtEnd()) return TOKEN_EOF;
 
-            UnescapedIdentifier.clear();
-            TStringOutput sout(UnescapedIdentifier);
-            TStringBuf atom = Str.SubStr(Index);
+            UnescapedIdentifier_.clear();
+            TStringOutput sout(UnescapedIdentifier_);
+            TStringBuf atom = Str_.SubStr(Index_);
             size_t readBytes = 0;
             EUnescapeResult unescapeResunt =
                     UnescapeArbitraryAtom(atom, '\'', &sout, &readBytes);
@@ -438,7 +438,7 @@ private:
 
             if (AtEnd()) return TOKEN_EOF;
 
-            Identifier = UnescapedIdentifier;
+            Identifier_ = UnescapedIdentifier_;
             return TOKEN_ESCAPED_IDENTIFIER;
         } else {
             Move(); // skip last char
@@ -465,14 +465,14 @@ private:
 
         // (1) parse argements
         for (;;) {
-            if (Token == TOKEN_EOF) {
+            if (Token_ == TOKEN_EOF) {
                 if (optArgsStarted) {
                     return AddError("Expected ']'");
                 }
                 return AddError("Expected ')'");
             }
 
-            if (Token == ']' || Token == ')') {
+            if (Token_ == ']' || Token_ == ')') {
                 break;
             }
 
@@ -481,30 +481,30 @@ private:
                 lastWasTypeStatement = false;
             }
 
-            if (Token == '[') {
+            if (Token_ == '[') {
                 optArgsStarted = true;
                 GetNextToken(); // eat '['
-            } else if (Token == ':') {
+            } else if (Token_ == ':') {
                 return AddError("Expected non empty argument name");
-            } else if (IsTypeKeyword(Token) || Token == '(' || // '(' - begin of callable type
-                       Token == TOKEN_IDENTIFIER ||
-                       Token == TOKEN_ESCAPED_IDENTIFIER)
+            } else if (IsTypeKeyword(Token_) || Token_ == '(' || // '(' - begin of callable type
+                       Token_ == TOKEN_IDENTIFIER ||
+                       Token_ == TOKEN_ESCAPED_IDENTIFIER)
             {
                 TStringBuf argName;
                 ui32 argNameFlags = TNodeFlags::Default;
 
                 if (LookaheadNonSpaceChar() == ':') {
                     namedArgsStarted = true;
-                    argName = Identifier;
+                    argName = Identifier_;
 
-                    if (Token == TOKEN_ESCAPED_IDENTIFIER) {
+                    if (Token_ == TOKEN_ESCAPED_IDENTIFIER) {
                         argNameFlags = TNodeFlags::ArbitraryContent;
                     }
 
                     GetNextToken(); // eat name
                     EXPECT_AND_SKIP_TOKEN(':', nullptr);
 
-                    if (Token == TOKEN_EOF) {
+                    if (Token_ == TOKEN_EOF) {
                         return AddError("Expected type of named argument");
                     }
                 } else {
@@ -531,7 +531,7 @@ private:
                 }
 
                 ui32 argFlags = 0;
-                if (Token == '{') {
+                if (Token_ == '{') {
                     if (!ParseCallableArgFlags(argFlags)) return nullptr;
                 }
 
@@ -572,7 +572,7 @@ private:
 
         // (4) parse payload
         TStringBuf payload;
-        if (Token == '{') {
+        if (Token_ == '{') {
             if (!ParseCallablePayload(payload)) return nullptr;
         }
 
@@ -583,7 +583,7 @@ private:
     bool ParseCallableArgFlags(ui32& argFlags) {
         GetNextToken(); // eat '{'
 
-        if (Token != TOKEN_IDENTIFIER || Identifier != TStringBuf("Flags")) {
+        if (Token_ != TOKEN_IDENTIFIER || Identifier_ != TStringBuf("Flags")) {
             AddError("Expected Flags field");
             return false;
         }
@@ -592,13 +592,13 @@ private:
         EXPECT_AND_SKIP_TOKEN(':', false);
 
         for (;;) {
-            if (Token == TOKEN_IDENTIFIER) {
-                if (Identifier == TStringBuf("AutoMap")) {
+            if (Token_ == TOKEN_IDENTIFIER) {
+                if (Identifier_ == TStringBuf("AutoMap")) {
                     argFlags |= NUdf::ICallablePayload::TArgumentFlags::AutoMap;
-                } else if (Identifier == TStringBuf("NoYield")) {
+                } else if (Identifier_ == TStringBuf("NoYield")) {
                     argFlags |= NUdf::ICallablePayload::TArgumentFlags::NoYield;
                 } else {
-                    AddError(TString("Unknown flag name: ") + Identifier);
+                    AddError(TString("Unknown flag name: ") + Identifier_);
                     return false;
                 }
                 GetNextToken(); // eat flag name
@@ -607,9 +607,9 @@ private:
                 return false;
             }
 
-            if (Token == '}') {
+            if (Token_ == '}') {
                 break;
-            } else if (Token == '|') {
+            } else if (Token_ == '|') {
                 GetNextToken(); // eat '|'
             } else {
                 AddError("Expected '}' or '|'");
@@ -623,7 +623,7 @@ private:
     bool ParseCallablePayload(TStringBuf& payload) {
         GetNextToken(); // eat '{'
 
-        if (Token != TOKEN_IDENTIFIER && Identifier != TStringBuf("Payload")) {
+        if (Token_ != TOKEN_IDENTIFIER && Identifier_ != TStringBuf("Payload")) {
             AddError("Expected Payload field");
             return false;
         }
@@ -631,8 +631,8 @@ private:
         GetNextToken(); // eat 'Payload'
         EXPECT_AND_SKIP_TOKEN(':', false);
 
-        if (Token == TOKEN_IDENTIFIER || Token == TOKEN_ESCAPED_IDENTIFIER) {
-            payload = Identifier;
+        if (Token_ == TOKEN_IDENTIFIER || Token_ == TOKEN_ESCAPED_IDENTIFIER) {
+            payload = Identifier_;
             GetNextToken(); // eat payload data
         } else {
             AddError("Expected payload data");
@@ -714,10 +714,10 @@ private:
         EXPECT_AND_SKIP_TOKEN('<', nullptr);
 
         TString file;
-        if (Token == TOKEN_IDENTIFIER ||
-            Token == TOKEN_ESCAPED_IDENTIFIER)
+        if (Token_ == TOKEN_IDENTIFIER ||
+            Token_ == TOKEN_ESCAPED_IDENTIFIER)
         {
-            file = Identifier;
+            file = Identifier_;
         } else {
             return AddError("Expected file name");
         }
@@ -725,26 +725,26 @@ private:
         GetNextToken(); // eat file name
         EXPECT_AND_SKIP_TOKEN(':', nullptr);
         ui32 line;
-        if (!(Token == TOKEN_IDENTIFIER ||
-            Token == TOKEN_ESCAPED_IDENTIFIER) || !TryFromString(Identifier, line)) {
+        if (!(Token_ == TOKEN_IDENTIFIER ||
+            Token_ == TOKEN_ESCAPED_IDENTIFIER) || !TryFromString(Identifier_, line)) {
             return AddError("Expected line");
         }
 
         GetNextToken();
         EXPECT_AND_SKIP_TOKEN(':', nullptr);
         ui32 column;
-        if (!(Token == TOKEN_IDENTIFIER ||
-            Token == TOKEN_ESCAPED_IDENTIFIER) || !TryFromString(Identifier, column)) {
+        if (!(Token_ == TOKEN_IDENTIFIER ||
+            Token_ == TOKEN_ESCAPED_IDENTIFIER) || !TryFromString(Identifier_, column)) {
             return AddError("Expected column");
         }
 
         GetNextToken();
         EXPECT_AND_SKIP_TOKEN(':', nullptr);
         TString message;
-        if (Token == TOKEN_IDENTIFIER ||
-            Token == TOKEN_ESCAPED_IDENTIFIER)
+        if (Token_ == TOKEN_IDENTIFIER ||
+            Token_ == TOKEN_ESCAPED_IDENTIFIER)
         {
-            message = Identifier;
+            message = Identifier_;
         } else {
             return AddError("Expected message");
         }
@@ -758,12 +758,12 @@ private:
         GetNextToken(); // eat keyword
         EXPECT_AND_SKIP_TOKEN('(', nullptr);
 
-        const auto precision = Identifier;
+        const auto precision = Identifier_;
         GetNextToken(); // eat keyword
 
         EXPECT_AND_SKIP_TOKEN(',', nullptr);
 
-        const auto scale = Identifier;
+        const auto scale = Identifier_;
         GetNextToken(); // eat keyword
 
         EXPECT_AND_SKIP_TOKEN(')', nullptr);
@@ -813,16 +813,16 @@ private:
         TSmallVec<TAstNode*> items;
         items.push_back(nullptr);  // reserve for type callable
 
-        if (Token != '>') {
+        if (Token_ != '>') {
             for (;;) {
                 auto itemType = ParseType();
                 if (!itemType) return nullptr;
 
                 items.push_back(itemType);
 
-                if (Token == '>') {
+                if (Token_ == '>') {
                     break;
-                } else if (Token == ',') {
+                } else if (Token_ == ',') {
                     GetNextToken();
                 } else {
                     return AddError("Expected '>' or ','");
@@ -845,13 +845,13 @@ private:
 
     TAstNode* ParseStructTypeImpl() {
         TMap<TString, TAstNode*> members;
-        if (Token != '>') {
+        if (Token_ != '>') {
             for (;;) {
                 TString name;
-                if (Token == TOKEN_IDENTIFIER ||
-                    Token == TOKEN_ESCAPED_IDENTIFIER)
+                if (Token_ == TOKEN_IDENTIFIER ||
+                    Token_ == TOKEN_ESCAPED_IDENTIFIER)
                 {
-                    name = Identifier;
+                    name = Identifier_;
                 } else {
                     return AddError("Expected struct member name");
                 }
@@ -870,9 +870,9 @@ private:
 
                 members.emplace(std::move(name), type);
 
-                if (Token == '>') {
+                if (Token_ == '>') {
                     break;
-                } else if (Token == ',') {
+                } else if (Token_ == ',') {
                     GetNextToken();
                 } else {
                     return AddError("Expected '>' or ','");
@@ -908,9 +908,9 @@ private:
         EXPECT_AND_SKIP_TOKEN('<', nullptr);
 
         TAstNode* underlyingType = nullptr;
-        if (Token == TOKEN_IDENTIFIER || Token == TOKEN_ESCAPED_IDENTIFIER) {
+        if (Token_ == TOKEN_IDENTIFIER || Token_ == TOKEN_ESCAPED_IDENTIFIER) {
             underlyingType = ParseStructTypeImpl();
-        } else if (IsTypeKeyword(Token) || Token == '(') {
+        } else if (IsTypeKeyword(Token_) || Token_ == '(') {
             underlyingType = ParseTupleTypeImpl(&TTypeParser::MakeTupleType);
         } else {
             return AddError("Expected type");
@@ -929,10 +929,10 @@ private:
         TMap<TString, TAstNode*> members;
         for (;;) {
             TString name;
-            if (Token == TOKEN_IDENTIFIER ||
-                Token == TOKEN_ESCAPED_IDENTIFIER)
+            if (Token_ == TOKEN_IDENTIFIER ||
+                Token_ == TOKEN_ESCAPED_IDENTIFIER)
             {
-                name = Identifier;
+                name = Identifier_;
             } else {
                 return AddError("Expected name");
             }
@@ -946,9 +946,9 @@ private:
             GetNextToken(); // eat member name
             members.emplace(std::move(name), MakeVoidType());
 
-            if (Token == '>') {
+            if (Token_ == '>') {
                 break;
-            } else if (Token == ',') {
+            } else if (Token_ == ',') {
                 GetNextToken();
             } else {
                 return AddError("Expected '>' or ','");
@@ -1082,11 +1082,11 @@ private:
         GetNextToken(); // eat keyword
         EXPECT_AND_SKIP_TOKEN('<', nullptr);
 
-        if (Token != TOKEN_IDENTIFIER && Token != TOKEN_ESCAPED_IDENTIFIER) {
+        if (Token_ != TOKEN_IDENTIFIER && Token_ != TOKEN_ESCAPED_IDENTIFIER) {
             return AddError("Expected resource tag");
         }
 
-        TStringBuf tag = Identifier;
+        TStringBuf tag = Identifier_;
         if (tag.empty()) {
             return AddError("Expected non empty resource tag");
         }
@@ -1105,11 +1105,11 @@ private:
 
         EXPECT_AND_SKIP_TOKEN(',', nullptr);
 
-        if (Token != TOKEN_IDENTIFIER && Token != TOKEN_ESCAPED_IDENTIFIER) {
+        if (Token_ != TOKEN_IDENTIFIER && Token_ != TOKEN_ESCAPED_IDENTIFIER) {
             return AddError("Expected tag of type");
         }
 
-        TStringBuf tag = Identifier;
+        TStringBuf tag = Identifier_;
         if (tag.empty()) {
             return AddError("Expected non empty tag of type");
         }
@@ -1214,11 +1214,11 @@ private:
     }
 
     TAstNode* MakeAtom(TStringBuf content, ui32 flags = TNodeFlags::Default) {
-        return TAstNode::NewAtom(Position, content, Pool, flags);
+        return TAstNode::NewAtom(Position_, content, Pool_, flags);
     }
 
     TAstNode* MakeLiteralAtom(TStringBuf content, ui32 flags = TNodeFlags::Default) {
-        return TAstNode::NewLiteralAtom(Position, content, Pool, flags);
+        return TAstNode::NewLiteralAtom(Position_, content, Pool_, flags);
     }
 
     TAstNode* MakeQuote(TAstNode* node) {
@@ -1238,43 +1238,43 @@ private:
     }
 
     TAstNode* MakeList(TAstNode** children, ui32 count) {
-        return TAstNode::NewList(Position, children, count, Pool);
+        return TAstNode::NewList(Position_, children, count, Pool_);
     }
 
     char Get() const {
-        return Str[Index];
+        return Str_[Index_];
     }
 
     bool AtEnd() const {
-        return Index >= Str.size();
+        return Index_ >= Str_.size();
     }
 
     void Move() {
         if (AtEnd()) return;
 
-        ++Index;
-        ++Position.Column;
+        ++Index_;
+        ++Position_.Column;
 
-        if (!AtEnd() && Str[Index] == '\n') {
-            Position.Row++;
-            Position.Column = 1;
+        if (!AtEnd() && Str_[Index_] == '\n') {
+            Position_.Row++;
+            Position_.Column = 1;
         }
     }
 
     TAstNode* AddError(const TString& message) {
-        Issues.AddIssue(TIssue(TokenBegin, message));
+        Issues_.AddIssue(TIssue(TokenBegin_, message));
         return nullptr;
     }
 
 private:
-    TStringBuf Str;
-    TIssues& Issues;
-    TPosition TokenBegin, Position;
-    size_t Index;
-    int Token;
-    TString UnescapedIdentifier;
-    TStringBuf Identifier;
-    TMemoryPool& Pool;
+    TStringBuf Str_;
+    TIssues& Issues_;
+    TPosition TokenBegin_, Position_;
+    size_t Index_;
+    int Token_;
+    TString UnescapedIdentifier_;
+    TStringBuf Identifier_;
+    TMemoryPool& Pool_;
 };
 
 //////////////////////////////////////////////////////////////////////////////
@@ -1290,13 +1290,13 @@ public:
 
 private:
     void Visit(const TUnitExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Y_UNUSED(type);
         Out_ << TStringBuf("Unit");
     }
 
     void Visit(const TMultiExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Multi<");
         const auto& items = type.GetItems();
         for (ui32 i = 0; i < items.size(); ++i) {
@@ -1309,7 +1309,7 @@ private:
     }
 
     void Visit(const TTupleExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Tuple<");
         const auto& items = type.GetItems();
         for (ui32 i = 0; i < items.size(); ++i) {
@@ -1322,7 +1322,7 @@ private:
     }
 
     void Visit(const TStructExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Struct<");
         const auto& items = type.GetItems();
         for (ui32 i = 0; i < items.size(); ++i) {
@@ -1335,49 +1335,49 @@ private:
     }
 
     void Visit(const TItemExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         EscapeArbitraryAtom(type.GetName(), '\'', &Out_);
         Out_ << ':';
         type.GetItemType()->Accept(*this);
     }
 
     void Visit(const TListExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("List<");
         type.GetItemType()->Accept(*this);
         Out_ << '>';
     }
 
     void Visit(const TStreamExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Stream<");
         type.GetItemType()->Accept(*this);
         Out_ << '>';
     }
 
     void Visit(const TFlowExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Flow<");
         type.GetItemType()->Accept(*this);
         Out_ << '>';
     }
 
     void Visit(const TBlockExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Block<");
         type.GetItemType()->Accept(*this);
         Out_ << '>';
     }
 
     void Visit(const TScalarExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Scalar<");
         type.GetItemType()->Accept(*this);
         Out_ << '>';
     }
 
     void Visit(const TDataExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << type.GetName();
         if (const auto dataExprParamsType = dynamic_cast<const TDataExprParamsType*>(&type)) {
             Out_ << '(' << dataExprParamsType->GetParamOne() << ',' << dataExprParamsType->GetParamTwo() << ')';
@@ -1385,7 +1385,7 @@ private:
     }
 
     void Visit(const TPgExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         TStringBuf name = type.GetName();
         if (!name.SkipPrefix("_")) {
             Out_ << "pg" << name;
@@ -1396,26 +1396,26 @@ private:
 
     void Visit(const TWorldExprType& type) final {
         Y_UNUSED(type);
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("World");
     }
 
     void Visit(const TOptionalExprType& type) final {
         const TTypeAnnotationNode* itemType = type.GetItemType();
-        if (TopLevel || itemType->GetKind() == ETypeAnnotationKind::Callable) {
-            TopLevel = false;
+        if (TopLevel_ || itemType->GetKind() == ETypeAnnotationKind::Callable) {
+            TopLevel_ = false;
             Out_ << TStringBuf("Optional<");
             itemType->Accept(*this);
             Out_ << '>';
         } else {
-            TopLevel = false;
+            TopLevel_ = false;
             itemType->Accept(*this);
             Out_ << '?';
         }
     }
 
     void Visit(const TCallableExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         const auto& args = type.GetArguments();
         ui32 argsCount = type.GetArgumentsSize();
         ui32 optArgsCount =
@@ -1471,21 +1471,21 @@ private:
     }
 
     void Visit(const TResourceExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Resource<");
         EscapeArbitraryAtom(type.GetTag(), '\'', &Out_);
         Out_ << '>';
     }
 
     void Visit(const TTypeExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Type<");
         type.GetType()->Accept(*this);
         Out_ << '>';
     }
 
     void Visit(const TDictExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         if (type.GetPayloadType()->GetKind() == ETypeAnnotationKind::Void) {
             Out_ << TStringBuf("Set<");
             type.GetKeyType()->Accept(*this);
@@ -1501,36 +1501,36 @@ private:
 
     void Visit(const TVoidExprType& type) final {
         Y_UNUSED(type);
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Void");
     }
 
     void Visit(const TNullExprType& type) final {
         Y_UNUSED(type);
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Null");
     }
 
     void Visit(const TEmptyListExprType& type) final {
         Y_UNUSED(type);
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("EmptyList");
     }
 
     void Visit(const TEmptyDictExprType& type) final {
         Y_UNUSED(type);
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("EmptyDict");
     }
 
     void Visit(const TGenericExprType& type) final {
         Y_UNUSED(type);
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Generic");
     }
 
     void Visit(const TTaggedExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Tagged<");
         type.GetBaseType()->Accept(*this);
         Out_ << ',';
@@ -1539,7 +1539,7 @@ private:
     }
 
     void Visit(const TErrorExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         Out_ << TStringBuf("Error<");
         auto pos = type.GetError().Position;
         EscapeArbitraryAtom(pos.File.empty() ? "<main>" : pos.File, '\'', &Out_);
@@ -1553,7 +1553,7 @@ private:
     }
 
     void Visit(const TVariantExprType& type) final {
-        TopLevel = false;
+        TopLevel_ = false;
         auto underlyingType = type.GetUnderlyingType();
         if (underlyingType->GetKind() == ETypeAnnotationKind::Tuple) {
             Out_ << TStringBuf("Variant<");
@@ -1592,7 +1592,7 @@ private:
 
 private:
     IOutputStream& Out_;
-    bool TopLevel = true;
+    bool TopLevel_ = true;
 };
 
 } // namespace