clang-tools-extra/unittests/clang-tidy/ModernizeModuleTest.cpp

   1 //===---- ModernizeModuleTest.cpp - clang-tidy ----------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 #include "ClangTidyTest.h"
   9 #include "modernize/IntegralLiteralExpressionMatcher.h"
  10 #include "clang/Lex/Lexer.h"
  11 #include "gtest/gtest.h"
  12
  13 #include <cstring>
  14 #include <iterator>
  15 #include <string>
  16 #include <vector>
  17
  18 namespace clang {
  19 namespace tidy {
  20 namespace test {
  21
  22 static std::vector<Token> tokenify(const char *Text) {
  23   LangOptions LangOpts;
  24   std::vector<std::string> Includes;
  25   LangOptions::setLangDefaults(LangOpts, Language::CXX, llvm::Triple(),
  26                                Includes, LangStandard::lang_cxx20);
  27   Lexer Lex(SourceLocation{}, LangOpts, Text, Text, Text + std::strlen(Text));
  28   std::vector<Token> Tokens;
  29   bool End = false;
  30   while (!End) {
  31     Token Tok;
  32     End = Lex.LexFromRawLexer(Tok);
  33     Tokens.push_back(Tok);
  34   }
  35
  36   return Tokens;
  37 }
  38
  39 static bool matchText(const char *Text, bool AllowComma) {
  40   std::vector<Token> Tokens{tokenify(Text)};
  41   modernize::IntegralLiteralExpressionMatcher Matcher(Tokens, AllowComma);
  42
  43   return Matcher.match();
  44 }
  45
  46 static modernize::LiteralSize sizeText(const char *Text) {
  47   std::vector<Token> Tokens{tokenify(Text)};
  48   modernize::IntegralLiteralExpressionMatcher Matcher(Tokens, true);
  49   if (Matcher.match())
  50     return Matcher.largestLiteralSize();
  51   return modernize::LiteralSize::Unknown;
  52 }
  53
  54 static const char *toString(modernize::LiteralSize Value) {
  55   switch (Value) {
  56   case modernize::LiteralSize::Int:
  57     return "Int";
  58   case modernize::LiteralSize::UnsignedInt:
  59     return "UnsignedInt";
  60   case modernize::LiteralSize::Long:
  61     return "Long";
  62   case modernize::LiteralSize::UnsignedLong:
  63     return "UnsignedLong";
  64   case modernize::LiteralSize::LongLong:
  65     return "LongLong";
  66   case modernize::LiteralSize::UnsignedLongLong:
  67     return "UnsignedLongLong";
  68   default:
  69     return "Unknown";
  70   }
  71 }
  72
  73 namespace {
  74
  75 struct MatchParam {
  76   bool AllowComma;
  77   bool Matched;
  78   const char *Text;
  79
  80   friend std::ostream &operator<<(std::ostream &Str, const MatchParam &Value) {
  81     return Str << "Allow operator,: " << std::boolalpha << Value.AllowComma
  82                << ", Matched: " << std::boolalpha << Value.Matched
  83                << ", Text: '" << Value.Text << '\'';
  84   }
  85 };
  86
  87 struct SizeParam {
  88   modernize::LiteralSize Size;
  89   const char *Text;
  90
  91   friend std::ostream &operator<<(std::ostream &Str, const SizeParam &Value) {
  92     return Str << "Size: " << toString(Value.Size) << ", Text: '" << Value.Text << '\'';
  93   }
  94 };
  95
  96 class MatcherTest : public ::testing::TestWithParam<MatchParam> {};
  97
  98 class SizeTest : public ::testing::TestWithParam<SizeParam> {};
  99
 100 } // namespace
 101
 102 static const MatchParam MatchParams[] = {
 103     // Accept integral literals.
 104     {true, true, "1"},
 105     {true, true, "0177"},
 106     {true, true, "0xdeadbeef"},
 107     {true, true, "0b1011"},
 108     {true, true, "'c'"},
 109     // Reject non-integral literals.
 110     {true, false, "1.23"},
 111     {true, false, "0x1p3"},
 112     {true, false, R"("string")"},
 113     {true, false, "1i"},
 114
 115     // Accept literals with these unary operators.
 116     {true, true, "-1"},
 117     {true, true, "+1"},
 118     {true, true, "~1"},
 119     {true, true, "!1"},
 120     // Reject invalid unary operators.
 121     {true, false, "1-"},
 122     {true, false, "1+"},
 123     {true, false, "1~"},
 124     {true, false, "1!"},
 125
 126     // Accept valid binary operators.
 127     {true, true, "1+1"},
 128     {true, true, "1-1"},
 129     {true, true, "1*1"},
 130     {true, true, "1/1"},
 131     {true, true, "1%2"},
 132     {true, true, "1<<1"},
 133     {true, true, "1>>1"},
 134     {true, true, "1<=>1"},
 135     {true, true, "1<1"},
 136     {true, true, "1>1"},
 137     {true, true, "1<=1"},
 138     {true, true, "1>=1"},
 139     {true, true, "1==1"},
 140     {true, true, "1!=1"},
 141     {true, true, "1&1"},
 142     {true, true, "1^1"},
 143     {true, true, "1|1"},
 144     {true, true, "1&&1"},
 145     {true, true, "1||1"},
 146     {true, true, "1+ +1"}, // A space is needed to avoid being tokenized as ++ or --.
 147     {true, true, "1- -1"},
 148     // Comma is only valid when inside parentheses.
 149     {true, true, "(1,1)"},
 150     // Reject invalid binary operators.
 151     {true, false, "1+"},
 152     {true, false, "1-"},
 153     {true, false, "1*"},
 154     {true, false, "1/"},
 155     {true, false, "1%"},
 156     {true, false, "1<<"},
 157     {true, false, "1>>"},
 158     {true, false, "1<=>"},
 159     {true, false, "1<"},
 160     {true, false, "1>"},
 161     {true, false, "1<="},
 162     {true, false, "1>="},
 163     {true, false, "1=="},
 164     {true, false, "1!="},
 165     {true, false, "1&"},
 166     {true, false, "1^"},
 167     {true, false, "1|"},
 168     {true, false, "1&&"},
 169     {true, false, "1||"},
 170     {true, false, "1,"},
 171     {true, false, ",1"},
 172     {true, false, "1,1"},
 173
 174     // Accept valid ternary operators.
 175     {true, true, "1?1:1"},
 176     {true, true, "1?:1"}, // A gcc extension treats x ? : y as x ? x : y.
 177     // Reject invalid ternary operators.
 178     {true, false, "?"},
 179     {true, false, "?1"},
 180     {true, false, "?:"},
 181     {true, false, "?:1"},
 182     {true, false, "?1:"},
 183     {true, false, "?1:1"},
 184     {true, false, "1?"},
 185     {true, false, "1?1"},
 186     {true, false, "1?:"},
 187     {true, false, "1?1:"},
 188
 189     // Accept parenthesized expressions.
 190     {true, true, "(1)"},
 191     {true, true, "((+1))"},
 192     {true, true, "((+(1)))"},
 193     {true, true, "(-1)"},
 194     {true, true, "-(1)"},
 195     {true, true, "(+1)"},
 196     {true, true, "((+1))"},
 197     {true, true, "+(1)"},
 198     {true, true, "(~1)"},
 199     {true, true, "~(1)"},
 200     {true, true, "(!1)"},
 201     {true, true, "!(1)"},
 202     {true, true, "(1+1)"},
 203     {true, true, "(1-1)"},
 204     {true, true, "(1*1)"},
 205     {true, true, "(1/1)"},
 206     {true, true, "(1%2)"},
 207     {true, true, "(1<<1)"},
 208     {true, true, "(1>>1)"},
 209     {true, true, "(1<=>1)"},
 210     {true, true, "(1<1)"},
 211     {true, true, "(1>1)"},
 212     {true, true, "(1<=1)"},
 213     {true, true, "(1>=1)"},
 214     {true, true, "(1==1)"},
 215     {true, true, "(1!=1)"},
 216     {true, true, "(1&1)"},
 217     {true, true, "(1^1)"},
 218     {true, true, "(1|1)"},
 219     {true, true, "(1&&1)"},
 220     {true, true, "(1||1)"},
 221     {true, true, "(1?1:1)"},
 222
 223     // Accept more complicated "chained" expressions.
 224     {true, true, "1+1+1"},
 225     {true, true, "1+1+1+1"},
 226     {true, true, "1+1+1+1+1"},
 227     {true, true, "1*1*1"},
 228     {true, true, "1*1*1*1"},
 229     {true, true, "1*1*1*1*1"},
 230     {true, true, "1<<1<<1"},
 231     {true, true, "4U>>1>>1"},
 232     {true, true, "1<1<1"},
 233     {true, true, "1>1>1"},
 234     {true, true, "1<=1<=1"},
 235     {true, true, "1>=1>=1"},
 236     {true, true, "1==1==1"},
 237     {true, true, "1!=1!=1"},
 238     {true, true, "1&1&1"},
 239     {true, true, "1^1^1"},
 240     {true, true, "1|1|1"},
 241     {true, true, "1&&1&&1"},
 242     {true, true, "1||1||1"},
 243     {true, true, "(1,1,1)"},
 244
 245     // Optionally reject comma operator
 246     {false, false, "1,1"}
 247 };
 248
 249 TEST_P(MatcherTest, MatchResult) {
 250   const MatchParam &Param = GetParam();
 251
 252   EXPECT_TRUE(matchText(Param.Text, Param.AllowComma) == Param.Matched);
 253 }
 254
 255 INSTANTIATE_TEST_SUITE_P(IntegralLiteralExpressionMatcherTests, MatcherTest,
 256                          ::testing::ValuesIn(MatchParams));
 257
 258 static const SizeParam SizeParams[] = {
 259     {modernize::LiteralSize::Int, "1"},
 260     {modernize::LiteralSize::UnsignedInt, "1U"},
 261     {modernize::LiteralSize::Long, "1L"},
 262     {modernize::LiteralSize::UnsignedLong, "1UL"},
 263     {modernize::LiteralSize::UnsignedLong, "1LU"},
 264     {modernize::LiteralSize::LongLong, "1LL"},
 265     {modernize::LiteralSize::UnsignedLongLong, "1ULL"},
 266     {modernize::LiteralSize::UnsignedLongLong, "1LLU"}};
 267
 268 TEST_P(SizeTest, TokenSize) {
 269   EXPECT_EQ(sizeText(GetParam().Text), GetParam().Size);
 270 }
 271
 272 INSTANTIATE_TEST_SUITE_P(IntegralLiteralExpressionMatcherTests, SizeTest,
 273                          ::testing::ValuesIn(SizeParams));
 274
 275 } // namespace test
 276 } // namespace tidy
 277 } // namespace clang