YQL-20086: Format yql/essentials/sql/v1/highlight

This patch adds a style check for `yql/essentials/sql/v1`.

To format use `ya style`.
To test use `ya test ya test --test-type clang_format`.

To enable style checking in a module, need to add:
`ENABLE(YQL_STYLE_CPP)`. So in a such way we gradually will
format all YQL modules, expect those, where fluent YQL-builders
are used. Then we will revert activation macro, so switch from
`ENABLE(YQL_STYLE_CPP)` to`ENABLE(YQL_STYLE_CPP_XFAIL)`.

Guide: <https://nda.ya.ru/t/XzkoRIGg7KjXmq>.
commit_hash:fa758a214e094c74821fe896184f30483dd18c55

9 files changed, 425 insertions, 423 deletions

diff --git a/yql/essentials/sql/v1/highlight/sql_highlight.cpp b/yql/essentials/sql/v1/highlight/sql_highlight.cpp
index b4f577eda67..72dd095ec3f 100644
--- a/yql/essentials/sql/v1/highlight/sql_highlight.cpp
+++ b/yql/essentials/sql/v1/highlight/sql_highlight.cpp
@@ -15,221 +15,221 @@
 
 namespace NSQLHighlight {
 
-    using NSQLTranslationV1::Merged;
-    using NSQLTranslationV1::TRegexPattern;
-
-    struct Syntax {
-        const NSQLReflect::TLexerGrammar* Grammar;
-        THashMap<TString, TString> RegexesDefault;
-        THashMap<TString, TString> RegexesANSI;
-
-        TString Concat(const TVector<TStringBuf>& names) {
-            TString concat;
-            for (const auto& name : names) {
-                concat += Get(name);
-            }
-            return concat;
+using NSQLTranslationV1::Merged;
+using NSQLTranslationV1::TRegexPattern;
+
+struct Syntax {
+    const NSQLReflect::TLexerGrammar* Grammar;
+    THashMap<TString, TString> RegexesDefault;
+    THashMap<TString, TString> RegexesANSI;
+
+    TString Concat(const TVector<TStringBuf>& names) {
+        TString concat;
+        for (const auto& name : names) {
+            concat += Get(name);
         }
+        return concat;
+    }
 
-        TString Get(const TStringBuf name, bool ansi = false) const {
-            if (Grammar->PunctuationNames.contains(name)) {
-                return RE2::QuoteMeta(Grammar->BlockByName.at(name));
-            }
-            if (ansi) {
-                return RegexesANSI.at(name);
-            }
-            return RegexesDefault.at(name);
+    TString Get(const TStringBuf name, bool ansi = false) const {
+        if (Grammar->PunctuationNames.contains(name)) {
+            return RE2::QuoteMeta(Grammar->BlockByName.at(name));
         }
-    };
-
-    NSQLTranslationV1::TRegexPattern CaseInsensitive(TStringBuf text) {
-        return {
-            .Body = TString(text),
-            .IsCaseInsensitive = true,
-        };
+        if (ansi) {
+            return RegexesANSI.at(name);
+        }
+        return RegexesDefault.at(name);
     }
+};
 
-    template <EUnitKind K>
-    TUnit MakeUnit(Syntax& syntax);
+NSQLTranslationV1::TRegexPattern CaseInsensitive(TStringBuf text) {
+    return {
+        .Body = TString(text),
+        .IsCaseInsensitive = true,
+    };
+}
 
-    template <>
-    TUnit MakeUnit<EUnitKind::Keyword>(Syntax& s) {
-        using NSQLReflect::TLexerGrammar;
+template <EUnitKind K>
+TUnit MakeUnit(Syntax& syntax);
 
-        TUnit unit = {.Kind = EUnitKind::Keyword};
-        for (const auto& keyword : s.Grammar->KeywordNames) {
-            const TStringBuf content = TLexerGrammar::KeywordBlockByName(keyword);
-            unit.Patterns.push_back(CaseInsensitive(content));
-        }
+template <>
+TUnit MakeUnit<EUnitKind::Keyword>(Syntax& s) {
+    using NSQLReflect::TLexerGrammar;
 
-        unit.Patterns = {Merged(std::move(unit.Patterns))};
-        return unit;
+    TUnit unit = {.Kind = EUnitKind::Keyword};
+    for (const auto& keyword : s.Grammar->KeywordNames) {
+        const TStringBuf content = TLexerGrammar::KeywordBlockByName(keyword);
+        unit.Patterns.push_back(CaseInsensitive(content));
     }
 
-    template <>
-    TUnit MakeUnit<EUnitKind::Punctuation>(Syntax& s) {
-        TUnit unit = {.Kind = EUnitKind::Punctuation};
-        for (const auto& name : s.Grammar->PunctuationNames) {
-            const TString content = s.Get(name);
-            unit.Patterns.push_back({content});
-        }
+    unit.Patterns = {Merged(std::move(unit.Patterns))};
+    return unit;
+}
 
-        unit.Patterns = {Merged(std::move(unit.Patterns))};
-        unit.IsPlain = false;
-        unit.IsCodeGenExcluded = true;
-        return unit;
+template <>
+TUnit MakeUnit<EUnitKind::Punctuation>(Syntax& s) {
+    TUnit unit = {.Kind = EUnitKind::Punctuation};
+    for (const auto& name : s.Grammar->PunctuationNames) {
+        const TString content = s.Get(name);
+        unit.Patterns.push_back({content});
     }
 
-    template <>
-    TUnit MakeUnit<EUnitKind::QuotedIdentifier>(Syntax& s) {
-        return {
-            .Kind = EUnitKind::QuotedIdentifier,
-            .Patterns = {
-                {s.Get("ID_QUOTED")},
-            },
-            .IsPlain = false,
-        };
-    }
+    unit.Patterns = {Merged(std::move(unit.Patterns))};
+    unit.IsPlain = false;
+    unit.IsCodeGenExcluded = true;
+    return unit;
+}
 
-    template <>
-    TUnit MakeUnit<EUnitKind::BindParameterIdentifier>(Syntax& s) {
-        return {
-            .Kind = EUnitKind::BindParameterIdentifier,
-            .Patterns = {
-                {s.Concat({"DOLLAR", "ID_PLAIN"})},
-            },
-            .IsPlain = false,
-        };
-    }
+template <>
+TUnit MakeUnit<EUnitKind::QuotedIdentifier>(Syntax& s) {
+    return {
+        .Kind = EUnitKind::QuotedIdentifier,
+        .Patterns = {
+            {s.Get("ID_QUOTED")},
+        },
+        .IsPlain = false,
+    };
+}
 
-    template <>
-    TUnit MakeUnit<EUnitKind::TypeIdentifier>(Syntax& s) {
-        TVector<NSQLTranslationV1::TRegexPattern> types;
-        NJson::TJsonValue json = NJson::ReadJsonFastTree(NResource::Find("types.json"));
-        for (const NJson::TJsonValue& value : json.GetArraySafe()) {
-            types.emplace_back(CaseInsensitive(value["name"].GetStringSafe()));
-        }
+template <>
+TUnit MakeUnit<EUnitKind::BindParameterIdentifier>(Syntax& s) {
+    return {
+        .Kind = EUnitKind::BindParameterIdentifier,
+        .Patterns = {
+            {s.Concat({"DOLLAR", "ID_PLAIN"})},
+        },
+        .IsPlain = false,
+    };
+}
 
-        return {
-            .Kind = EUnitKind::TypeIdentifier,
-            .Patterns = {
-                {s.Get("ID_PLAIN"), s.Get("LESS")},
-                {Merged(std::move(types))},
-            },
-        };
+template <>
+TUnit MakeUnit<EUnitKind::TypeIdentifier>(Syntax& s) {
+    TVector<NSQLTranslationV1::TRegexPattern> types;
+    NJson::TJsonValue json = NJson::ReadJsonFastTree(NResource::Find("types.json"));
+    for (const NJson::TJsonValue& value : json.GetArraySafe()) {
+        types.emplace_back(CaseInsensitive(value["name"].GetStringSafe()));
     }
 
-    template <>
-    TUnit MakeUnit<EUnitKind::FunctionIdentifier>(Syntax& s) {
-        return {
-            .Kind = EUnitKind::FunctionIdentifier,
-            .Patterns = {
-                {s.Concat({"ID_PLAIN", "NAMESPACE", "ID_PLAIN"})},
-                {s.Get("ID_PLAIN"), s.Get("LPAREN")},
-            },
-        };
-    }
+    return {
+        .Kind = EUnitKind::TypeIdentifier,
+        .Patterns = {
+            {s.Get("ID_PLAIN"), s.Get("LESS")},
+            {Merged(std::move(types))},
+        },
+    };
+}
 
-    template <>
-    TUnit MakeUnit<EUnitKind::Identifier>(Syntax& s) {
-        return {
-            .Kind = EUnitKind::Identifier,
-            .Patterns = {
-                {s.Get("ID_PLAIN")},
-            },
-        };
-    }
+template <>
+TUnit MakeUnit<EUnitKind::FunctionIdentifier>(Syntax& s) {
+    return {
+        .Kind = EUnitKind::FunctionIdentifier,
+        .Patterns = {
+            {s.Concat({"ID_PLAIN", "NAMESPACE", "ID_PLAIN"})},
+            {s.Get("ID_PLAIN"), s.Get("LPAREN")},
+        },
+    };
+}
 
-    template <>
-    TUnit MakeUnit<EUnitKind::Literal>(Syntax& s) {
-        return {
-            .Kind = EUnitKind::Literal,
-            .Patterns = {
-                {s.Get("REAL")},
-                {s.Get("INTEGER_VALUE")},
-                {s.Get("DIGITS")},
-            },
-        };
-    }
+template <>
+TUnit MakeUnit<EUnitKind::Identifier>(Syntax& s) {
+    return {
+        .Kind = EUnitKind::Identifier,
+        .Patterns = {
+            {s.Get("ID_PLAIN")},
+        },
+    };
+}
 
-    template <>
-    TUnit MakeUnit<EUnitKind::StringLiteral>(Syntax& s) {
-        return {
-            .Kind = EUnitKind::StringLiteral,
-            .Patterns = {{s.Get("STRING_VALUE")}},
-            .PatternsANSI = TVector<TRegexPattern>{
-                TRegexPattern{s.Get("STRING_VALUE", /* ansi = */ true)},
-            },
-            .RangePattern = TRangePattern{
-                .Begin = R"(@@)",
-                .End = R"(@@)",
-            },
-            .IsPlain = false,
-        };
-    }
+template <>
+TUnit MakeUnit<EUnitKind::Literal>(Syntax& s) {
+    return {
+        .Kind = EUnitKind::Literal,
+        .Patterns = {
+            {s.Get("REAL")},
+            {s.Get("INTEGER_VALUE")},
+            {s.Get("DIGITS")},
+        },
+    };
+}
 
-    template <>
-    TUnit MakeUnit<EUnitKind::Comment>(Syntax& s) {
-        return {
-            .Kind = EUnitKind::Comment,
-            .Patterns = {{s.Get("COMMENT")}},
-            .PatternsANSI = Nothing(),
-            .RangePattern = TRangePattern{
-                .Begin = R"(/*)",
-                .End = R"(*/)",
-            },
-            .IsPlain = false,
-        };
-    }
+template <>
+TUnit MakeUnit<EUnitKind::StringLiteral>(Syntax& s) {
+    return {
+        .Kind = EUnitKind::StringLiteral,
+        .Patterns = {{s.Get("STRING_VALUE")}},
+        .PatternsANSI = TVector<TRegexPattern>{
+            TRegexPattern{s.Get("STRING_VALUE", /* ansi = */ true)},
+        },
+        .RangePattern = TRangePattern{
+            .Begin = R"(@@)",
+            .End = R"(@@)",
+        },
+        .IsPlain = false,
+    };
+}
 
-    template <>
-    TUnit MakeUnit<EUnitKind::Whitespace>(Syntax& s) {
-        return {
-            .Kind = EUnitKind::Whitespace,
-            .Patterns = {
-                {s.Get("WS")},
-            },
-            .IsPlain = false,
-            .IsCodeGenExcluded = true,
-        };
-    }
+template <>
+TUnit MakeUnit<EUnitKind::Comment>(Syntax& s) {
+    return {
+        .Kind = EUnitKind::Comment,
+        .Patterns = {{s.Get("COMMENT")}},
+        .PatternsANSI = Nothing(),
+        .RangePattern = TRangePattern{
+            .Begin = R"(/*)",
+            .End = R"(*/)",
+        },
+        .IsPlain = false,
+    };
+}
 
-    Syntax MakeSyntax(const NSQLReflect::TLexerGrammar& grammar) {
-        using NSQLTranslationV1::MakeRegexByOtherName;
+template <>
+TUnit MakeUnit<EUnitKind::Whitespace>(Syntax& s) {
+    return {
+        .Kind = EUnitKind::Whitespace,
+        .Patterns = {
+            {s.Get("WS")},
+        },
+        .IsPlain = false,
+        .IsCodeGenExcluded = true,
+    };
+}
 
-        Syntax syntax;
-        syntax.Grammar = &grammar;
-        for (auto& [k, v] : MakeRegexByOtherName(*syntax.Grammar, /* ansi = */ false)) {
-            syntax.RegexesDefault.emplace(std::move(k), std::move(v));
-        }
-        for (auto& [k, v] : MakeRegexByOtherName(*syntax.Grammar, /* ansi = */ true)) {
-            syntax.RegexesANSI.emplace(std::move(k), std::move(v));
-        }
-        return syntax;
-    }
+Syntax MakeSyntax(const NSQLReflect::TLexerGrammar& grammar) {
+    using NSQLTranslationV1::MakeRegexByOtherName;
 
-    THighlighting MakeHighlighting() {
-        return MakeHighlighting(NSQLReflect::LoadLexerGrammar());
+    Syntax syntax;
+    syntax.Grammar = &grammar;
+    for (auto& [k, v] : MakeRegexByOtherName(*syntax.Grammar, /* ansi = */ false)) {
+        syntax.RegexesDefault.emplace(std::move(k), std::move(v));
     }
-
-    THighlighting MakeHighlighting(const NSQLReflect::TLexerGrammar& grammar) {
-        Syntax s = MakeSyntax(grammar);
-
-        THighlighting h;
-        h.Units.emplace_back(MakeUnit<EUnitKind::Comment>(s));
-        h.Units.emplace_back(MakeUnit<EUnitKind::Punctuation>(s));
-        h.Units.emplace_back(MakeUnit<EUnitKind::FunctionIdentifier>(s));
-        h.Units.emplace_back(MakeUnit<EUnitKind::TypeIdentifier>(s));
-        h.Units.emplace_back(MakeUnit<EUnitKind::Keyword>(s));
-        h.Units.emplace_back(MakeUnit<EUnitKind::QuotedIdentifier>(s));
-        h.Units.emplace_back(MakeUnit<EUnitKind::BindParameterIdentifier>(s));
-        h.Units.emplace_back(MakeUnit<EUnitKind::Identifier>(s));
-        h.Units.emplace_back(MakeUnit<EUnitKind::Literal>(s));
-        h.Units.emplace_back(MakeUnit<EUnitKind::StringLiteral>(s));
-        h.Units.emplace_back(MakeUnit<EUnitKind::Whitespace>(s));
-
-        return h;
+    for (auto& [k, v] : MakeRegexByOtherName(*syntax.Grammar, /* ansi = */ true)) {
+        syntax.RegexesANSI.emplace(std::move(k), std::move(v));
     }
+    return syntax;
+}
+
+THighlighting MakeHighlighting() {
+    return MakeHighlighting(NSQLReflect::LoadLexerGrammar());
+}
+
+THighlighting MakeHighlighting(const NSQLReflect::TLexerGrammar& grammar) {
+    Syntax s = MakeSyntax(grammar);
+
+    THighlighting h;
+    h.Units.emplace_back(MakeUnit<EUnitKind::Comment>(s));
+    h.Units.emplace_back(MakeUnit<EUnitKind::Punctuation>(s));
+    h.Units.emplace_back(MakeUnit<EUnitKind::FunctionIdentifier>(s));
+    h.Units.emplace_back(MakeUnit<EUnitKind::TypeIdentifier>(s));
+    h.Units.emplace_back(MakeUnit<EUnitKind::Keyword>(s));
+    h.Units.emplace_back(MakeUnit<EUnitKind::QuotedIdentifier>(s));
+    h.Units.emplace_back(MakeUnit<EUnitKind::BindParameterIdentifier>(s));
+    h.Units.emplace_back(MakeUnit<EUnitKind::Identifier>(s));
+    h.Units.emplace_back(MakeUnit<EUnitKind::Literal>(s));
+    h.Units.emplace_back(MakeUnit<EUnitKind::StringLiteral>(s));
+    h.Units.emplace_back(MakeUnit<EUnitKind::Whitespace>(s));
+
+    return h;
+}
 
 } // namespace NSQLHighlight
 
diff --git a/yql/essentials/sql/v1/highlight/sql_highlight.h b/yql/essentials/sql/v1/highlight/sql_highlight.h
index 79a53629614..df11668bbf0 100644
--- a/yql/essentials/sql/v1/highlight/sql_highlight.h
+++ b/yql/essentials/sql/v1/highlight/sql_highlight.h
@@ -12,43 +12,43 @@
 
 namespace NSQLHighlight {
 
-    enum class EUnitKind {
-        Keyword,
-        Punctuation,
-        QuotedIdentifier,
-        BindParameterIdentifier,
-        TypeIdentifier,
-        FunctionIdentifier,
-        Identifier,
-        Literal,
-        StringLiteral,
-        Comment,
-        Whitespace,
-        Error,
-    };
-
-    struct TRangePattern {
-        TString Begin;
-        TString End;
-    };
-
-    struct TUnit {
-        EUnitKind Kind;
-        TVector<NSQLTranslationV1::TRegexPattern> Patterns;
-        TMaybe<TVector<NSQLTranslationV1::TRegexPattern>> PatternsANSI;
-        TMaybe<TRangePattern> RangePattern;
-        bool IsPlain = true;
-        bool IsCodeGenExcluded = false;
-    };
-
-    struct THighlighting {
-        TString Name = "YQL";
-        TString Extension = "yql";
-        TVector<TUnit> Units;
-    };
-
-    THighlighting MakeHighlighting();
-
-    THighlighting MakeHighlighting(const NSQLReflect::TLexerGrammar& grammar);
+enum class EUnitKind {
+    Keyword,
+    Punctuation,
+    QuotedIdentifier,
+    BindParameterIdentifier,
+    TypeIdentifier,
+    FunctionIdentifier,
+    Identifier,
+    Literal,
+    StringLiteral,
+    Comment,
+    Whitespace,
+    Error,
+};
+
+struct TRangePattern {
+    TString Begin;
+    TString End;
+};
+
+struct TUnit {
+    EUnitKind Kind;
+    TVector<NSQLTranslationV1::TRegexPattern> Patterns;
+    TMaybe<TVector<NSQLTranslationV1::TRegexPattern>> PatternsANSI;
+    TMaybe<TRangePattern> RangePattern;
+    bool IsPlain = true;
+    bool IsCodeGenExcluded = false;
+};
+
+struct THighlighting {
+    TString Name = "YQL";
+    TString Extension = "yql";
+    TVector<TUnit> Units;
+};
+
+THighlighting MakeHighlighting();
+
+THighlighting MakeHighlighting(const NSQLReflect::TLexerGrammar& grammar);
 
 } // namespace NSQLHighlight
diff --git a/yql/essentials/sql/v1/highlight/sql_highlight_json.cpp b/yql/essentials/sql/v1/highlight/sql_highlight_json.cpp
index e4af680cdb9..eb41141358f 100644
--- a/yql/essentials/sql/v1/highlight/sql_highlight_json.cpp
+++ b/yql/essentials/sql/v1/highlight/sql_highlight_json.cpp
@@ -4,64 +4,64 @@
 
 namespace NSQLHighlight {
 
+struct {
+    const char* Units = "units";
     struct {
-        const char* Units = "units";
-        struct {
-            const char* Kind = "kind";
-            const char* Patterns = "patterns";
-            const char* PatternsANSI = "patterns-ansi";
-        } Unit;
-        struct {
-            const char* Body = "body";
-            const char* After = "after";
-            const char* IsCaseInsensitive = "is-case-insensitive";
-        } Pattern;
-    } JsonKey;
+        const char* Kind = "kind";
+        const char* Patterns = "patterns";
+        const char* PatternsANSI = "patterns-ansi";
+    } Unit;
+    struct {
+        const char* Body = "body";
+        const char* After = "after";
+        const char* IsCaseInsensitive = "is-case-insensitive";
+    } Pattern;
+} JsonKey;
 
-    NJson::TJsonValue ToJson(const NSQLTranslationV1::TRegexPattern& pattern) {
-        NJson::TJsonMap map;
-        map[JsonKey.Pattern.Body] = pattern.Body;
-        if (!pattern.After.empty()) {
-            map[JsonKey.Pattern.After] = pattern.After;
-        }
-        if (pattern.IsCaseInsensitive) {
-            map[JsonKey.Pattern.IsCaseInsensitive] = pattern.IsCaseInsensitive;
-        }
-        return map;
+NJson::TJsonValue ToJson(const NSQLTranslationV1::TRegexPattern& pattern) {
+    NJson::TJsonMap map;
+    map[JsonKey.Pattern.Body] = pattern.Body;
+    if (!pattern.After.empty()) {
+        map[JsonKey.Pattern.After] = pattern.After;
     }
-
-    NJson::TJsonValue ToJson(const TVector<NSQLTranslationV1::TRegexPattern>& patterns) {
-        NJson::TJsonArray array;
-        for (const auto& pattern : patterns) {
-            array.AppendValue(ToJson(pattern));
-        }
-        return array;
+    if (pattern.IsCaseInsensitive) {
+        map[JsonKey.Pattern.IsCaseInsensitive] = pattern.IsCaseInsensitive;
     }
+    return map;
+}
 
-    NJson::TJsonValue ToJson(const TUnit& unit) {
-        NJson::TJsonMap map;
-        map[JsonKey.Unit.Kind] = ToString(unit.Kind);
-        if (!unit.Patterns.empty()) {
-            map[JsonKey.Unit.Patterns] = ToJson(unit.Patterns);
-        }
-        if (!unit.PatternsANSI.Empty()) {
-            map[JsonKey.Unit.PatternsANSI] = ToJson(*unit.PatternsANSI);
-        }
-        return map;
+NJson::TJsonValue ToJson(const TVector<NSQLTranslationV1::TRegexPattern>& patterns) {
+    NJson::TJsonArray array;
+    for (const auto& pattern : patterns) {
+        array.AppendValue(ToJson(pattern));
     }
+    return array;
+}
 
-    NJson::TJsonValue ToJson(const TVector<TUnit>& units) {
-        NJson::TJsonArray array;
-        for (const auto& unit : units) {
-            array.AppendValue(ToJson(unit));
-        }
-        return array;
+NJson::TJsonValue ToJson(const TUnit& unit) {
+    NJson::TJsonMap map;
+    map[JsonKey.Unit.Kind] = ToString(unit.Kind);
+    if (!unit.Patterns.empty()) {
+        map[JsonKey.Unit.Patterns] = ToJson(unit.Patterns);
     }
+    if (!unit.PatternsANSI.Empty()) {
+        map[JsonKey.Unit.PatternsANSI] = ToJson(*unit.PatternsANSI);
+    }
+    return map;
+}
 
-    NJson::TJsonValue ToJson(const THighlighting& highlighting) {
-        NJson::TJsonMap map;
-        map[JsonKey.Units] = ToJson(highlighting.Units);
-        return map;
+NJson::TJsonValue ToJson(const TVector<TUnit>& units) {
+    NJson::TJsonArray array;
+    for (const auto& unit : units) {
+        array.AppendValue(ToJson(unit));
     }
+    return array;
+}
+
+NJson::TJsonValue ToJson(const THighlighting& highlighting) {
+    NJson::TJsonMap map;
+    map[JsonKey.Units] = ToJson(highlighting.Units);
+    return map;
+}
 
 } // namespace NSQLHighlight
diff --git a/yql/essentials/sql/v1/highlight/sql_highlight_json.h b/yql/essentials/sql/v1/highlight/sql_highlight_json.h
index 96df7c15a78..4da88943166 100644
--- a/yql/essentials/sql/v1/highlight/sql_highlight_json.h
+++ b/yql/essentials/sql/v1/highlight/sql_highlight_json.h
@@ -6,6 +6,6 @@
 
 namespace NSQLHighlight {
 
-    NJson::TJsonValue ToJson(const THighlighting& highlighting);
+NJson::TJsonValue ToJson(const THighlighting& highlighting);
 
 } // namespace NSQLHighlight
diff --git a/yql/essentials/sql/v1/highlight/sql_highlight_json_ut.cpp b/yql/essentials/sql/v1/highlight/sql_highlight_json_ut.cpp
index 0329ad32320..763f72818f1 100644
--- a/yql/essentials/sql/v1/highlight/sql_highlight_json_ut.cpp
+++ b/yql/essentials/sql/v1/highlight/sql_highlight_json_ut.cpp
@@ -6,9 +6,9 @@ using namespace NSQLHighlight;
 
 Y_UNIT_TEST_SUITE(SqlHighlightJsonTests) {
 
-    Y_UNIT_TEST(Smoke) {
-        NJson::TJsonValue json = ToJson(MakeHighlighting());
-        UNIT_ASSERT(json.Has("units"));
-    }
+Y_UNIT_TEST(Smoke) {
+    NJson::TJsonValue json = ToJson(MakeHighlighting());
+    UNIT_ASSERT(json.Has("units"));
+}
 
 } // Y_UNIT_TEST_SUITE(SqlHighlightJsonTests)
diff --git a/yql/essentials/sql/v1/highlight/sql_highlighter.cpp b/yql/essentials/sql/v1/highlight/sql_highlighter.cpp
index e44695d0a28..bbba982c6f5 100644
--- a/yql/essentials/sql/v1/highlight/sql_highlighter.cpp
+++ b/yql/essentials/sql/v1/highlight/sql_highlighter.cpp
@@ -9,125 +9,125 @@
 
 namespace NSQLHighlight {
 
-    using NSQLTranslationV1::Compile;
-    using NSQLTranslationV1::IGenericLexer;
-    using NSQLTranslationV1::TGenericLexerGrammar;
-    using NSQLTranslationV1::TGenericToken;
-
-    THashMap<EUnitKind, TString> NamesByUnitKind = [] {
-        THashMap<EUnitKind, TString> names;
-        names[EUnitKind::Keyword] = "K";
-        names[EUnitKind::Punctuation] = "P";
-        names[EUnitKind::QuotedIdentifier] = "Q";
-        names[EUnitKind::BindParameterIdentifier] = "B";
-        names[EUnitKind::TypeIdentifier] = "T";
-        names[EUnitKind::FunctionIdentifier] = "F";
-        names[EUnitKind::Identifier] = "I";
-        names[EUnitKind::Literal] = "L";
-        names[EUnitKind::StringLiteral] = "S";
-        names[EUnitKind::Comment] = "C";
-        names[EUnitKind::Whitespace] = "W";
-        names[EUnitKind::Error] = TGenericToken::Error;
-        return names;
-    }();
-
-    THashMap<TString, EUnitKind> UnitKindsByName = [] {
-        THashMap<TString, EUnitKind> kinds;
-        for (const auto& [kind, name] : NamesByUnitKind) {
-            Y_ENSURE(!kinds.contains(name));
-            kinds[name] = kind;
-        }
-        return kinds;
-    }();
-
-    TGenericLexerGrammar ToGenericLexerGrammar(const THighlighting& highlighting, bool ansi) {
-        using NSQLTranslationV1::ANSICommentMatcher;
+using NSQLTranslationV1::Compile;
+using NSQLTranslationV1::IGenericLexer;
+using NSQLTranslationV1::TGenericLexerGrammar;
+using NSQLTranslationV1::TGenericToken;
+
+THashMap<EUnitKind, TString> NamesByUnitKind = [] {
+    THashMap<EUnitKind, TString> names;
+    names[EUnitKind::Keyword] = "K";
+    names[EUnitKind::Punctuation] = "P";
+    names[EUnitKind::QuotedIdentifier] = "Q";
+    names[EUnitKind::BindParameterIdentifier] = "B";
+    names[EUnitKind::TypeIdentifier] = "T";
+    names[EUnitKind::FunctionIdentifier] = "F";
+    names[EUnitKind::Identifier] = "I";
+    names[EUnitKind::Literal] = "L";
+    names[EUnitKind::StringLiteral] = "S";
+    names[EUnitKind::Comment] = "C";
+    names[EUnitKind::Whitespace] = "W";
+    names[EUnitKind::Error] = TGenericToken::Error;
+    return names;
+}();
+
+THashMap<TString, EUnitKind> UnitKindsByName = [] {
+    THashMap<TString, EUnitKind> kinds;
+    for (const auto& [kind, name] : NamesByUnitKind) {
+        Y_ENSURE(!kinds.contains(name));
+        kinds[name] = kind;
+    }
+    return kinds;
+}();
 
-        TGenericLexerGrammar grammar;
-        for (const auto& unit : highlighting.Units) {
-            const auto* patterns = &unit.Patterns;
-            if (!unit.PatternsANSI.Empty() && ansi) {
-                patterns = unit.PatternsANSI.Get();
-            }
+TGenericLexerGrammar ToGenericLexerGrammar(const THighlighting& highlighting, bool ansi) {
+    using NSQLTranslationV1::ANSICommentMatcher;
 
-            const auto& name = NamesByUnitKind.at(unit.Kind);
+    TGenericLexerGrammar grammar;
+    for (const auto& unit : highlighting.Units) {
+        const auto* patterns = &unit.Patterns;
+        if (!unit.PatternsANSI.Empty() && ansi) {
+            patterns = unit.PatternsANSI.Get();
+        }
 
-            if (unit.Kind == EUnitKind::Comment && ansi) {
-                Y_ENSURE(unit.Patterns.size() == 1);
-                auto matcher = Compile(name, unit.Patterns[0]);
-                grammar.emplace_back(ANSICommentMatcher(name, std::move(matcher)));
-            }
+        const auto& name = NamesByUnitKind.at(unit.Kind);
 
-            for (const auto& pattern : *patterns) {
-                grammar.emplace_back(Compile(name, pattern));
-            }
+        if (unit.Kind == EUnitKind::Comment && ansi) {
+            Y_ENSURE(unit.Patterns.size() == 1);
+            auto matcher = Compile(name, unit.Patterns[0]);
+            grammar.emplace_back(ANSICommentMatcher(name, std::move(matcher)));
         }
-        return grammar;
-    }
 
-    class THighlighter: public IHighlighter {
-    public:
-        explicit THighlighter(NSQLTranslationV1::IGenericLexer::TPtr lexer)
-            : Lexer_(std::move(lexer))
-        {
+        for (const auto& pattern : *patterns) {
+            grammar.emplace_back(Compile(name, pattern));
         }
+    }
+    return grammar;
+}
+
+class THighlighter: public IHighlighter {
+public:
+    explicit THighlighter(NSQLTranslationV1::IGenericLexer::TPtr lexer)
+        : Lexer_(std::move(lexer))
+    {
+    }
 
-        bool Tokenize(TStringBuf text, const TTokenCallback& onNext, size_t maxErrors) const override {
-            const auto onNextToken = [&](NSQLTranslationV1::TGenericToken&& token) {
-                if (token.Name == "EOF") {
-                    return;
-                }
+    bool Tokenize(TStringBuf text, const TTokenCallback& onNext, size_t maxErrors) const override {
+        const auto onNextToken = [&](NSQLTranslationV1::TGenericToken&& token) {
+            if (token.Name == "EOF") {
+                return;
+            }
 
-                onNext({
-                    .Kind = UnitKindsByName.at(token.Name),
-                    .Begin = token.Begin,
-                    .Length = token.Content.size(),
-                });
-            };
+            onNext({
+                .Kind = UnitKindsByName.at(token.Name),
+                .Begin = token.Begin,
+                .Length = token.Content.size(),
+            });
+        };
 
-            return Lexer_->Tokenize(text, onNextToken, maxErrors);
-        }
+        return Lexer_->Tokenize(text, onNextToken, maxErrors);
+    }
 
-    private:
-        NSQLTranslationV1::IGenericLexer::TPtr Lexer_;
-    };
-
-    class TCombinedHighlighter: public IHighlighter {
-    public:
-        explicit TCombinedHighlighter(const THighlighting& highlighting)
-            : LexerDefault_(NSQLTranslationV1::MakeGenericLexer(
-                  ToGenericLexerGrammar(highlighting, /* ansi = */ false)))
-            , LexerANSI_(NSQLTranslationV1::MakeGenericLexer(
-                  ToGenericLexerGrammar(highlighting, /* ansi = */ true)))
-        {
-        }
+private:
+    NSQLTranslationV1::IGenericLexer::TPtr Lexer_;
+};
+
+class TCombinedHighlighter: public IHighlighter {
+public:
+    explicit TCombinedHighlighter(const THighlighting& highlighting)
+        : LexerDefault_(NSQLTranslationV1::MakeGenericLexer(
+              ToGenericLexerGrammar(highlighting, /* ansi = */ false)))
+        , LexerANSI_(NSQLTranslationV1::MakeGenericLexer(
+              ToGenericLexerGrammar(highlighting, /* ansi = */ true)))
+    {
+    }
 
-        bool Tokenize(TStringBuf text, const TTokenCallback& onNext, size_t maxErrors) const override {
-            return Alt(text).Tokenize(text, onNext, maxErrors);
-        }
+    bool Tokenize(TStringBuf text, const TTokenCallback& onNext, size_t maxErrors) const override {
+        return Alt(text).Tokenize(text, onNext, maxErrors);
+    }
 
-    private:
-        const IHighlighter& Alt(TStringBuf text) const {
-            if (text.After('-').StartsWith("-!ansi_lexer")) {
-                return LexerANSI_;
-            }
-            return LexerDefault_;
+private:
+    const IHighlighter& Alt(TStringBuf text) const {
+        if (text.After('-').StartsWith("-!ansi_lexer")) {
+            return LexerANSI_;
         }
-
-        THighlighter LexerDefault_;
-        THighlighter LexerANSI_;
-    };
-
-    TVector<TToken> Tokenize(IHighlighter& highlighter, TStringBuf text) {
-        TVector<TToken> tokens;
-        highlighter.Tokenize(text, [&](TToken&& token) {
-            tokens.emplace_back(std::move(token));
-        });
-        return tokens;
+        return LexerDefault_;
     }
 
-    IHighlighter::TPtr MakeHighlighter(const THighlighting& highlighting) {
-        return IHighlighter::TPtr(new TCombinedHighlighter(highlighting));
-    }
+    THighlighter LexerDefault_;
+    THighlighter LexerANSI_;
+};
+
+TVector<TToken> Tokenize(IHighlighter& highlighter, TStringBuf text) {
+    TVector<TToken> tokens;
+    highlighter.Tokenize(text, [&](TToken&& token) {
+        tokens.emplace_back(std::move(token));
+    });
+    return tokens;
+}
+
+IHighlighter::TPtr MakeHighlighter(const THighlighting& highlighting) {
+    return IHighlighter::TPtr(new TCombinedHighlighter(highlighting));
+}
 
 } // namespace NSQLHighlight
diff --git a/yql/essentials/sql/v1/highlight/sql_highlighter.h b/yql/essentials/sql/v1/highlight/sql_highlighter.h
index 39b5e93242d..c0dae510b86 100644
--- a/yql/essentials/sql/v1/highlight/sql_highlighter.h
+++ b/yql/essentials/sql/v1/highlight/sql_highlighter.h
@@ -9,26 +9,26 @@
 
 namespace NSQLHighlight {
 
-    struct TToken {
-        EUnitKind Kind;
-        size_t Begin;  // In bytes
-        size_t Length; // In bytes
-    };
-
-    class IHighlighter: public TThrRefBase {
-    public:
-        using TPtr = TIntrusivePtr<IHighlighter>;
-        using TTokenCallback = std::function<void(TToken&& token)>;
-
-        virtual ~IHighlighter() = default;
-        virtual bool Tokenize(
-            TStringBuf text,
-            const TTokenCallback& onNext,
-            size_t maxErrors = Max<size_t>()) const = 0;
-    };
-
-    TVector<TToken> Tokenize(IHighlighter& highlighter, TStringBuf text);
-
-    IHighlighter::TPtr MakeHighlighter(const THighlighting& highlighting);
+struct TToken {
+    EUnitKind Kind;
+    size_t Begin;  // In bytes
+    size_t Length; // In bytes
+};
+
+class IHighlighter: public TThrRefBase {
+public:
+    using TPtr = TIntrusivePtr<IHighlighter>;
+    using TTokenCallback = std::function<void(TToken&& token)>;
+
+    virtual ~IHighlighter() = default;
+    virtual bool Tokenize(
+        TStringBuf text,
+        const TTokenCallback& onNext,
+        size_t maxErrors = Max<size_t>()) const = 0;
+};
+
+TVector<TToken> Tokenize(IHighlighter& highlighter, TStringBuf text);
+
+IHighlighter::TPtr MakeHighlighter(const THighlighting& highlighting);
 
 } // namespace NSQLHighlight
diff --git a/yql/essentials/sql/v1/highlight/sql_highlighter_ut.cpp b/yql/essentials/sql/v1/highlight/sql_highlighter_ut.cpp
index 86ecb1f3306..bff14bc2e38 100644
--- a/yql/essentials/sql/v1/highlight/sql_highlighter_ut.cpp
+++ b/yql/essentials/sql/v1/highlight/sql_highlighter_ut.cpp
@@ -81,26 +81,26 @@ TString Mask(IHighlighter::TPtr& h, TStringBuf text) {
 
 Y_UNIT_TEST_SUITE(SqlHighlighterTests) {
 
-    Y_UNIT_TEST(Suite) {
-        auto h = MakeHighlighter(MakeHighlighting());
-        size_t count = 0;
-        Cerr << "{" << Endl;
-        for (const auto& test : LoadTestSuite()) {
-            Cerr << "  \"" << test.Name << "\": [" << Endl;
-            for (size_t i = 0; i < test.Cases.size(); ++i) {
-                const auto& check = test.Cases[i];
-                const auto actual = Mask(h, check.Input);
-                Cerr << "    [\"" << EscapeC(check.Input) << "\", \"" << actual << "\"]," << Endl;
-                UNIT_ASSERT_VALUES_EQUAL_C(
-                    actual,
-                    check.Expected,
-                    test.Name << " #" << i << ": Input = '" << check.Input << "'");
-                count += 1;
-            }
-            Cerr << "  ]," << Endl;
+Y_UNIT_TEST(Suite) {
+    auto h = MakeHighlighter(MakeHighlighting());
+    size_t count = 0;
+    Cerr << "{" << Endl;
+    for (const auto& test : LoadTestSuite()) {
+        Cerr << "  \"" << test.Name << "\": [" << Endl;
+        for (size_t i = 0; i < test.Cases.size(); ++i) {
+            const auto& check = test.Cases[i];
+            const auto actual = Mask(h, check.Input);
+            Cerr << "    [\"" << EscapeC(check.Input) << "\", \"" << actual << "\"]," << Endl;
+            UNIT_ASSERT_VALUES_EQUAL_C(
+                actual,
+                check.Expected,
+                test.Name << " #" << i << ": Input = '" << check.Input << "'");
+            count += 1;
         }
-        Cerr << "}" << Endl;
-        Cerr << "Test Cases Executed: " << count << Endl;
+        Cerr << "  ]," << Endl;
     }
+    Cerr << "}" << Endl;
+    Cerr << "Test Cases Executed: " << count << Endl;
+}
 
 } // Y_UNIT_TEST_SUITE(SqlHighlighterTests)
diff --git a/yql/essentials/sql/v1/highlight/ya.make b/yql/essentials/sql/v1/highlight/ya.make
index 103f1908aa0..79baad0d9e2 100644
--- a/yql/essentials/sql/v1/highlight/ya.make
+++ b/yql/essentials/sql/v1/highlight/ya.make
@@ -1,3 +1,5 @@
+ENABLE(YQL_STYLE_CPP)
+
 LIBRARY()
 
 SRCS(