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

1 files changed, 104 insertions, 104 deletions

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