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

   1 //===--- UppercaseLiteralSuffixCheck.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
   9 #include "UppercaseLiteralSuffixCheck.h"
  10 #include "../utils/ASTUtils.h"
  11 #include "clang/AST/ASTContext.h"
  12 #include "clang/ASTMatchers/ASTMatchFinder.h"
  13 #include "clang/Lex/Lexer.h"
  14 #include "llvm/ADT/SmallString.h"
  15 #include <cctype>
  16 #include <optional>
  17
  18 using namespace clang::ast_matchers;
  19
  20 namespace clang::tidy::readability {
  21
  22 namespace {
  23
  24 struct IntegerLiteralCheck {
  25   using type = clang::IntegerLiteral;
  26   static constexpr llvm::StringLiteral Name = llvm::StringLiteral("integer");
  27   // What should be skipped before looking for the Suffixes? (Nothing here.)
  28   static constexpr llvm::StringLiteral SkipFirst = llvm::StringLiteral("");
  29   // Suffix can only consist of 'u' and 'l' chars, and can be a complex number
  30   // ('i', 'j'). In MS compatibility mode, suffixes like i32 are supported.
  31   static constexpr llvm::StringLiteral Suffixes =
  32       llvm::StringLiteral("uUlLiIjJ");
  33 };
  34 constexpr llvm::StringLiteral IntegerLiteralCheck::Name;
  35 constexpr llvm::StringLiteral IntegerLiteralCheck::SkipFirst;
  36 constexpr llvm::StringLiteral IntegerLiteralCheck::Suffixes;
  37
  38 struct FloatingLiteralCheck {
  39   using type = clang::FloatingLiteral;
  40   static constexpr llvm::StringLiteral Name =
  41       llvm::StringLiteral("floating point");
  42   // C++17 introduced hexadecimal floating-point literals, and 'f' is both a
  43   // valid hexadecimal digit in a hex float literal and a valid floating-point
  44   // literal suffix.
  45   // So we can't just "skip to the chars that can be in the suffix".
  46   // Since the exponent ('p'/'P') is mandatory for hexadecimal floating-point
  47   // literals, we first skip everything before the exponent.
  48   static constexpr llvm::StringLiteral SkipFirst = llvm::StringLiteral("pP");
  49   // Suffix can only consist of 'f', 'l', "f16", 'h', 'q' chars,
  50   // and can be a complex number ('i', 'j').
  51   static constexpr llvm::StringLiteral Suffixes =
  52       llvm::StringLiteral("fFlLhHqQiIjJ");
  53 };
  54 constexpr llvm::StringLiteral FloatingLiteralCheck::Name;
  55 constexpr llvm::StringLiteral FloatingLiteralCheck::SkipFirst;
  56 constexpr llvm::StringLiteral FloatingLiteralCheck::Suffixes;
  57
  58 struct NewSuffix {
  59   SourceRange LiteralLocation;
  60   StringRef OldSuffix;
  61   std::optional<FixItHint> FixIt;
  62 };
  63
  64 std::optional<SourceLocation> getMacroAwareLocation(SourceLocation Loc,
  65                                                     const SourceManager &SM) {
  66   // Do nothing if the provided location is invalid.
  67   if (Loc.isInvalid())
  68     return std::nullopt;
  69   // Look where the location was *actually* written.
  70   SourceLocation SpellingLoc = SM.getSpellingLoc(Loc);
  71   if (SpellingLoc.isInvalid())
  72     return std::nullopt;
  73   return SpellingLoc;
  74 }
  75
  76 std::optional<SourceRange> getMacroAwareSourceRange(SourceRange Loc,
  77                                                     const SourceManager &SM) {
  78   std::optional<SourceLocation> Begin =
  79       getMacroAwareLocation(Loc.getBegin(), SM);
  80   std::optional<SourceLocation> End = getMacroAwareLocation(Loc.getEnd(), SM);
  81   if (!Begin || !End)
  82     return std::nullopt;
  83   return SourceRange(*Begin, *End);
  84 }
  85
  86 std::optional<std::string>
  87 getNewSuffix(llvm::StringRef OldSuffix,
  88              const std::vector<StringRef> &NewSuffixes) {
  89   // If there is no config, just uppercase the entirety of the suffix.
  90   if (NewSuffixes.empty())
  91     return OldSuffix.upper();
  92   // Else, find matching suffix, case-*insensitive*ly.
  93   auto NewSuffix =
  94       llvm::find_if(NewSuffixes, [OldSuffix](StringRef PotentialNewSuffix) {
  95         return OldSuffix.equals_insensitive(PotentialNewSuffix);
  96       });
  97   // Have a match, return it.
  98   if (NewSuffix != NewSuffixes.end())
  99     return NewSuffix->str();
 100   // Nope, I guess we have to keep it as-is.
 101   return std::nullopt;
 102 }
 103
 104 template <typename LiteralType>
 105 std::optional<NewSuffix>
 106 shouldReplaceLiteralSuffix(const Expr &Literal,
 107                            const std::vector<StringRef> &NewSuffixes,
 108                            const SourceManager &SM, const LangOptions &LO) {
 109   NewSuffix ReplacementDsc;
 110
 111   const auto &L = cast<typename LiteralType::type>(Literal);
 112
 113   // The naive location of the literal. Is always valid.
 114   ReplacementDsc.LiteralLocation = L.getSourceRange();
 115
 116   // Was this literal fully spelled or is it a product of macro expansion?
 117   bool RangeCanBeFixed =
 118       utils::rangeCanBeFixed(ReplacementDsc.LiteralLocation, &SM);
 119
 120   // The literal may have macro expansion, we need the final expanded src range.
 121   std::optional<SourceRange> Range =
 122       getMacroAwareSourceRange(ReplacementDsc.LiteralLocation, SM);
 123   if (!Range)
 124     return std::nullopt;
 125
 126   if (RangeCanBeFixed)
 127     ReplacementDsc.LiteralLocation = *Range;
 128   // Else keep the naive literal location!
 129
 130   // Get the whole literal from the source buffer.
 131   bool Invalid = false;
 132   const StringRef LiteralSourceText = Lexer::getSourceText(
 133       CharSourceRange::getTokenRange(*Range), SM, LO, &Invalid);
 134   assert(!Invalid && "Failed to retrieve the source text.");
 135
 136   // Make sure the first character is actually a digit, instead of
 137   // something else, like a non-type template parameter.
 138   if (!std::isdigit(static_cast<unsigned char>(LiteralSourceText.front())))
 139     return std::nullopt;
 140
 141   size_t Skip = 0;
 142
 143   // Do we need to ignore something before actually looking for the suffix?
 144   if (!LiteralType::SkipFirst.empty()) {
 145     // E.g. we can't look for 'f' suffix in hexadecimal floating-point literals
 146     // until after we skip to the exponent (which is mandatory there),
 147     // because hex-digit-sequence may contain 'f'.
 148     Skip = LiteralSourceText.find_first_of(LiteralType::SkipFirst);
 149     // We could be in non-hexadecimal floating-point literal, with no exponent.
 150     if (Skip == StringRef::npos)
 151       Skip = 0;
 152   }
 153
 154   // Find the beginning of the suffix by looking for the first char that is
 155   // one of these chars that can be in the suffix, potentially starting looking
 156   // in the exponent, if we are skipping hex-digit-sequence.
 157   Skip = LiteralSourceText.find_first_of(LiteralType::Suffixes, /*From=*/Skip);
 158
 159   // We can't check whether the *Literal has any suffix or not without actually
 160   // looking for the suffix. So it is totally possible that there is no suffix.
 161   if (Skip == StringRef::npos)
 162     return std::nullopt;
 163
 164   // Move the cursor in the source range to the beginning of the suffix.
 165   Range->setBegin(Range->getBegin().getLocWithOffset(Skip));
 166   // And in our textual representation too.
 167   ReplacementDsc.OldSuffix = LiteralSourceText.drop_front(Skip);
 168   assert(!ReplacementDsc.OldSuffix.empty() &&
 169          "We still should have some chars left.");
 170
 171   // And get the replacement suffix.
 172   std::optional<std::string> NewSuffix =
 173       getNewSuffix(ReplacementDsc.OldSuffix, NewSuffixes);
 174   if (!NewSuffix || ReplacementDsc.OldSuffix == *NewSuffix)
 175     return std::nullopt; // The suffix was already the way it should be.
 176
 177   if (RangeCanBeFixed)
 178     ReplacementDsc.FixIt = FixItHint::CreateReplacement(*Range, *NewSuffix);
 179
 180   return ReplacementDsc;
 181 }
 182
 183 } // namespace
 184
 185 UppercaseLiteralSuffixCheck::UppercaseLiteralSuffixCheck(
 186     StringRef Name, ClangTidyContext *Context)
 187     : ClangTidyCheck(Name, Context),
 188       NewSuffixes(
 189           utils::options::parseStringList(Options.get("NewSuffixes", ""))),
 190       IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
 191
 192 void UppercaseLiteralSuffixCheck::storeOptions(
 193     ClangTidyOptions::OptionMap &Opts) {
 194   Options.store(Opts, "NewSuffixes",
 195                 utils::options::serializeStringList(NewSuffixes));
 196   Options.store(Opts, "IgnoreMacros", IgnoreMacros);
 197 }
 198
 199 void UppercaseLiteralSuffixCheck::registerMatchers(MatchFinder *Finder) {
 200   // Sadly, we can't check whether the literal has suffix or not.
 201   // E.g. i32 suffix still results in 'BuiltinType::Kind::Int'.
 202   // And such an info is not stored in the *Literal itself.
 203   Finder->addMatcher(
 204       stmt(eachOf(integerLiteral().bind(IntegerLiteralCheck::Name),
 205                   floatLiteral().bind(FloatingLiteralCheck::Name)),
 206            unless(anyOf(hasParent(userDefinedLiteral()),
 207                         hasAncestor(substNonTypeTemplateParmExpr())))),
 208       this);
 209 }
 210
 211 template <typename LiteralType>
 212 bool UppercaseLiteralSuffixCheck::checkBoundMatch(
 213     const MatchFinder::MatchResult &Result) {
 214   const auto *Literal =
 215       Result.Nodes.getNodeAs<typename LiteralType::type>(LiteralType::Name);
 216   if (!Literal)
 217     return false;
 218
 219   // We won't *always* want to diagnose.
 220   // We might have a suffix that is already uppercase.
 221   if (auto Details = shouldReplaceLiteralSuffix<LiteralType>(
 222           *Literal, NewSuffixes, *Result.SourceManager, getLangOpts())) {
 223     if (Details->LiteralLocation.getBegin().isMacroID() && IgnoreMacros)
 224       return true;
 225     auto Complaint = diag(Details->LiteralLocation.getBegin(),
 226                           "%0 literal has suffix '%1', which is not uppercase")
 227                      << LiteralType::Name << Details->OldSuffix;
 228     if (Details->FixIt) // Similarly, a fix-it is not always possible.
 229       Complaint << *(Details->FixIt);
 230   }
 231
 232   return true;
 233 }
 234
 235 void UppercaseLiteralSuffixCheck::check(
 236     const MatchFinder::MatchResult &Result) {
 237   if (checkBoundMatch<IntegerLiteralCheck>(Result))
 238     return; // If it *was* IntegerLiteral, don't check for FloatingLiteral.
 239   checkBoundMatch<FloatingLiteralCheck>(Result);
 240 }
 241
 242 } // namespace clang::tidy::readability