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, 187 insertions, 187 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