clang-tools-extra/clang-tidy/bugprone/ReservedIdentifierCheck.cpp

   1 //===--- ReservedIdentifierCheck.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 "ReservedIdentifierCheck.h"
  10 #include "../utils/Matchers.h"
  11 #include "../utils/OptionsUtils.h"
  12 #include "clang/AST/ASTContext.h"
  13 #include "clang/ASTMatchers/ASTMatchFinder.h"
  14 #include "clang/Lex/Token.h"
  15 #include <algorithm>
  16 #include <cctype>
  17 #include <optional>
  18
  19 // FixItHint
  20
  21 using namespace clang::ast_matchers;
  22
  23 namespace clang::tidy::bugprone {
  24
  25 static const char DoubleUnderscoreTag[] = "du";
  26 static const char UnderscoreCapitalTag[] = "uc";
  27 static const char GlobalUnderscoreTag[] = "global-under";
  28 static const char NonReservedTag[] = "non-reserved";
  29
  30 static const char Message[] =
  31     "declaration uses identifier '%0', which is %select{a reserved "
  32     "identifier|not a reserved identifier|reserved in the global namespace}1";
  33
  34 static int getMessageSelectIndex(StringRef Tag) {
  35   if (Tag == NonReservedTag)
  36     return 1;
  37   if (Tag == GlobalUnderscoreTag)
  38     return 2;
  39   return 0;
  40 }
  41
  42 llvm::SmallVector<llvm::Regex>
  43 ReservedIdentifierCheck::parseAllowedIdentifiers() const {
  44   llvm::SmallVector<llvm::Regex> AllowedIdentifiers;
  45   AllowedIdentifiers.reserve(AllowedIdentifiersRaw.size());
  46
  47   for (const auto &Identifier : AllowedIdentifiersRaw) {
  48     AllowedIdentifiers.emplace_back(Identifier.str());
  49     if (!AllowedIdentifiers.back().isValid()) {
  50       configurationDiag("Invalid allowed identifier regex '%0'") << Identifier;
  51       AllowedIdentifiers.pop_back();
  52     }
  53   }
  54
  55   return AllowedIdentifiers;
  56 }
  57
  58 ReservedIdentifierCheck::ReservedIdentifierCheck(StringRef Name,
  59                                                  ClangTidyContext *Context)
  60     : RenamerClangTidyCheck(Name, Context),
  61       Invert(Options.get("Invert", false)),
  62       AllowedIdentifiersRaw(utils::options::parseStringList(
  63           Options.get("AllowedIdentifiers", ""))),
  64       AllowedIdentifiers(parseAllowedIdentifiers()) {}
  65
  66 void ReservedIdentifierCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
  67   RenamerClangTidyCheck::storeOptions(Opts);
  68   Options.store(Opts, "Invert", Invert);
  69   Options.store(Opts, "AllowedIdentifiers",
  70                 utils::options::serializeStringList(AllowedIdentifiersRaw));
  71 }
  72
  73 static std::string collapseConsecutive(StringRef Str, char C) {
  74   std::string Result;
  75   std::unique_copy(Str.begin(), Str.end(), std::back_inserter(Result),
  76                    [C](char A, char B) { return A == C && B == C; });
  77   return Result;
  78 }
  79
  80 static bool hasReservedDoubleUnderscore(StringRef Name,
  81                                         const LangOptions &LangOpts) {
  82   if (LangOpts.CPlusPlus)
  83     return Name.contains("__");
  84   return Name.starts_with("__");
  85 }
  86
  87 static std::optional<std::string>
  88 getDoubleUnderscoreFixup(StringRef Name, const LangOptions &LangOpts) {
  89   if (hasReservedDoubleUnderscore(Name, LangOpts))
  90     return collapseConsecutive(Name, '_');
  91   return std::nullopt;
  92 }
  93
  94 static bool startsWithUnderscoreCapital(StringRef Name) {
  95   return Name.size() >= 2 && Name[0] == '_' && std::isupper(Name[1]);
  96 }
  97
  98 static std::optional<std::string> getUnderscoreCapitalFixup(StringRef Name) {
  99   if (startsWithUnderscoreCapital(Name))
 100     return std::string(Name.drop_front(1));
 101   return std::nullopt;
 102 }
 103
 104 static bool startsWithUnderscoreInGlobalNamespace(StringRef Name,
 105                                                   bool IsInGlobalNamespace,
 106                                                   bool IsMacro) {
 107   return !IsMacro && IsInGlobalNamespace && Name.starts_with("_");
 108 }
 109
 110 static std::optional<std::string>
 111 getUnderscoreGlobalNamespaceFixup(StringRef Name, bool IsInGlobalNamespace,
 112                                   bool IsMacro) {
 113   if (startsWithUnderscoreInGlobalNamespace(Name, IsInGlobalNamespace, IsMacro))
 114     return std::string(Name.drop_front(1));
 115   return std::nullopt;
 116 }
 117
 118 static std::string getNonReservedFixup(std::string Name) {
 119   assert(!Name.empty());
 120   if (Name[0] == '_' || std::isupper(Name[0]))
 121     Name.insert(Name.begin(), '_');
 122   else
 123     Name.insert(Name.begin(), 2, '_');
 124   return Name;
 125 }
 126
 127 static std::optional<RenamerClangTidyCheck::FailureInfo>
 128 getFailureInfoImpl(StringRef Name, bool IsInGlobalNamespace, bool IsMacro,
 129                    const LangOptions &LangOpts, bool Invert,
 130                    ArrayRef<llvm::Regex> AllowedIdentifiers) {
 131   assert(!Name.empty());
 132
 133   if (llvm::any_of(AllowedIdentifiers, [&](const llvm::Regex &Regex) {
 134         return Regex.match(Name);
 135       })) {
 136     return std::nullopt;
 137   }
 138   // TODO: Check for names identical to language keywords, and other names
 139   // specifically reserved by language standards, e.g. C++ 'zombie names' and C
 140   // future library directions
 141
 142   using FailureInfo = RenamerClangTidyCheck::FailureInfo;
 143   if (!Invert) {
 144     std::optional<FailureInfo> Info;
 145     auto AppendFailure = [&](StringRef Kind, std::string &&Fixup) {
 146       if (!Info) {
 147         Info = FailureInfo{std::string(Kind), std::move(Fixup)};
 148       } else {
 149         Info->KindName += Kind;
 150         Info->Fixup = std::move(Fixup);
 151       }
 152     };
 153     auto InProgressFixup = [&] {
 154       return llvm::transformOptional(
 155                  Info,
 156                  [](const FailureInfo &Info) { return StringRef(Info.Fixup); })
 157           .value_or(Name);
 158     };
 159     if (auto Fixup = getDoubleUnderscoreFixup(InProgressFixup(), LangOpts))
 160       AppendFailure(DoubleUnderscoreTag, std::move(*Fixup));
 161     if (auto Fixup = getUnderscoreCapitalFixup(InProgressFixup()))
 162       AppendFailure(UnderscoreCapitalTag, std::move(*Fixup));
 163     if (auto Fixup = getUnderscoreGlobalNamespaceFixup(
 164             InProgressFixup(), IsInGlobalNamespace, IsMacro))
 165       AppendFailure(GlobalUnderscoreTag, std::move(*Fixup));
 166
 167     return Info;
 168   }
 169   if (!(hasReservedDoubleUnderscore(Name, LangOpts) ||
 170         startsWithUnderscoreCapital(Name) ||
 171         startsWithUnderscoreInGlobalNamespace(Name, IsInGlobalNamespace,
 172                                               IsMacro)))
 173     return FailureInfo{NonReservedTag, getNonReservedFixup(std::string(Name))};
 174   return std::nullopt;
 175 }
 176
 177 std::optional<RenamerClangTidyCheck::FailureInfo>
 178 ReservedIdentifierCheck::getDeclFailureInfo(const NamedDecl *Decl,
 179                                             const SourceManager &) const {
 180   assert(Decl && Decl->getIdentifier() && !Decl->getName().empty() &&
 181          "Decl must be an explicit identifier with a name.");
 182   // Implicit identifiers cannot fail.
 183   if (Decl->isImplicit())
 184     return std::nullopt;
 185
 186   return getFailureInfoImpl(
 187       Decl->getName(), isa<TranslationUnitDecl>(Decl->getDeclContext()),
 188       /*IsMacro = */ false, getLangOpts(), Invert, AllowedIdentifiers);
 189 }
 190
 191 std::optional<RenamerClangTidyCheck::FailureInfo>
 192 ReservedIdentifierCheck::getMacroFailureInfo(const Token &MacroNameTok,
 193                                              const SourceManager &) const {
 194   return getFailureInfoImpl(MacroNameTok.getIdentifierInfo()->getName(), true,
 195                             /*IsMacro = */ true, getLangOpts(), Invert,
 196                             AllowedIdentifiers);
 197 }
 198
 199 RenamerClangTidyCheck::DiagInfo
 200 ReservedIdentifierCheck::getDiagInfo(const NamingCheckId &ID,
 201                                      const NamingCheckFailure &Failure) const {
 202   return DiagInfo{Message, [&](DiagnosticBuilder &Diag) {
 203                     Diag << ID.second
 204                          << getMessageSelectIndex(Failure.Info.KindName);
 205                   }};
 206 }
 207
 208 } // namespace clang::tidy::bugprone