[clang-tidy] add IgnoreMacros option to readability-uppercase-literal-suffix

[vmiklos]

Summary

And also enable it by default to be consistent with e.g. modernize-use-using.

This helps e.g. when running this check on client code where the macro is provided by the system, so there is no easy way to modify it.

[lebedev.ri]

test/clang-tidy/readability-uppercase-literal-suffix-integer-macro.cpp

2–3 ↗

(On Diff #179354)

And the positive test?

[vmiklos]

test/clang-tidy/readability-uppercase-literal-suffix-integer-macro.cpp

2–3 ↗

(On Diff #179354)

Added a positive test now. :-)

[lebedev.ri]

LG i guess.

[JonasToth]

LGTM, do you have commit rights?

[vmiklos]

In D56025#1340618, @JonasToth wrote:

LGTM, do you have commit rights?

Yes, thanks. Committed now.

clang-tools-extra/trunk/clang-tidy/readability/UppercaseLiteralSuffixCheck.h

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   template <typename LiteralType>
   bool checkBoundMatch(const ast_matchers::MatchFinder::MatchResult &Result);
 
   const std::vector<std::string> NewSuffixes;
+  const bool IgnoreMacros;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UPPERCASELITERALSUFFIXCHECK_H

clang-tools-extra/trunk/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

 }
 
 } // namespace
 
 UppercaseLiteralSuffixCheck::UppercaseLiteralSuffixCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       NewSuffixes(
-          utils::options::parseStringList(Options.get("NewSuffixes", ""))) {}
+          utils::options::parseStringList(Options.get("NewSuffixes", ""))),
+      IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", 1) != 0) {}
 
 void UppercaseLiteralSuffixCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "NewSuffixes",
                 utils::options::serializeStringList(NewSuffixes));
+  Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 }
 
 void UppercaseLiteralSuffixCheck::registerMatchers(MatchFinder *Finder) {
   // Sadly, we can't check whether the literal has sufix or not.
   // E.g. i32 suffix still results in 'BuiltinType::Kind::Int'.
   // And such an info is not stored in the *Literal itself.
   Finder->addMatcher(
       stmt(eachOf(integerLiteral().bind(IntegerLiteralCheck::Name),
const auto *Literal =
       Result.Nodes.getNodeAs<typename LiteralType::type>(LiteralType::Name);
   if (!Literal)
     return false;
 
   // We won't *always* want to diagnose.
   // We might have a suffix that is already uppercase.
   if (auto Details = shouldReplaceLiteralSuffix<LiteralType>(
           *Literal, NewSuffixes, *Result.SourceManager, getLangOpts())) {
+    if (Details->LiteralLocation.getBegin().isMacroID() && IgnoreMacros)
+      return true;
     auto Complaint = diag(Details->LiteralLocation.getBegin(),
                           "%0 literal has suffix '%1', which is not uppercase")
                      << LiteralType::Name << Details->OldSuffix;
     if (Details->FixIt) // Similarly, a fix-it is not always possible.
       Complaint << *(Details->FixIt);
   }
 
   return true;

clang-tools-extra/trunk/docs/ReleaseNotes.rst

- New alias :doc:`hicpp-uppercase-literal-suffix
   :doc:`readability-uppercase-literal-suffix
   <clang-tidy/checks/readability-uppercase-literal-suffix>`
   added.
 
 - The :doc:`readability-redundant-smartptr-get
   <clang-tidy/checks/readability-redundant-smartptr-get>` check does not warn
   about calls inside macros anymore by default.
 
+- The :doc:`readability-uppercase-literal-suffix
+  <clang-tidy/checks/readability-uppercase-literal-suffix>` check does not warn
+  about literal suffixes inside macros anymore by default.
+
 - The :doc:`cppcoreguidelines-narrowing-conversions
   <clang-tidy/checks/cppcoreguidelines-narrowing-conversions>` check now
   detects more narrowing conversions:
   - integer to narrower signed integer (this is compiler implementation defined),
   - integer - floating point narrowing conversions,
   - floating point - integer narrowing conversions,
   - constants with narrowing conversions (even in ternary operator).
 

clang-tools-extra/trunk/docs/clang-tidy/checks/readability-uppercase-literal-suffix.rst

 * ``l`` -> ``L``
 * ``L`` will be kept as is.
 * ``ul`` -> ``uL``
 * ``Ul`` -> ``uL``
 * ``UL`` -> ``uL``
 * ``uL`` will be kept as is.
 * ``ull`` will be kept as is, since it is not in the list
 * and so on.
+
+.. option:: IgnoreMacros
+
+   If this option is set to non-zero (default is `1`), the check will not warn
+   about literal suffixes inside macros.

clang-tools-extra/trunk/test/clang-tidy/readability-uppercase-literal-suffix-integer-macro.cpp

-// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- -- -I %S
+// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- \
+// RUN:   -config="{CheckOptions: [{key: readability-uppercase-literal-suffix.IgnoreMacros, value: 0}]}" \
+// RUN:   -- -I %S
 
 void macros() {
 #define INMACRO(X) 1.f
   static constexpr auto m1 = INMACRO();
   // CHECK-NOTES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
   // CHECK-NOTES: :[[@LINE-3]]:20: note: expanded from macro 'INMACRO'
   // CHECK-FIXES: #define INMACRO(X) 1.f
   // CHECK-FIXES: static constexpr auto m1 = INMACRO();

clang-tools-extra/trunk/test/clang-tidy/readability-uppercase-literal-suffix-integer.cpp

#define PASSTHROUGH(X) X
   static constexpr auto m0 = PASSTHROUGH(1u);
   // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: integer literal has suffix 'u', which is not uppercase
   // CHECK-MESSAGES-NEXT: static constexpr auto m0 = PASSTHROUGH(1u);
   // CHECK-MESSAGES-NEXT: ^~
   // CHECK-MESSAGES-NEXT: {{^ *}}U{{$}}
   // CHECK-FIXES: static constexpr auto m0 = PASSTHROUGH(1U);
   static_assert(is_same<decltype(m0), const unsigned int>::value, "");
   static_assert(m0 == 1, "");
+
+  // This location is inside a macro, no warning on that by default.
+#define MACRO 1u
+  int foo = MACRO;
 }
 
 // Check that user-defined literals do not cause any diags.
 
 unsigned long long int operator"" _ull(unsigned long long int);
 void user_defined_literals() {
   1_ull;
 }