clang-tools  14.0.0git
IntegerTypesCheck.cpp
Go to the documentation of this file.
1 //===--- IntegerTypesCheck.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 "IntegerTypesCheck.h"
10 #include "clang/AST/ASTContext.h"
11 #include "clang/ASTMatchers/ASTMatchFinder.h"
12 #include "clang/ASTMatchers/ASTMatchers.h"
13 #include "clang/Basic/AttrKinds.h"
14 #include "clang/Basic/CharInfo.h"
15 #include "clang/Basic/IdentifierTable.h"
16 #include "clang/Basic/TargetInfo.h"
17 #include "clang/Lex/Lexer.h"
18 
19 namespace clang {
20 
21 using namespace ast_matchers;
22 
23 static Token getTokenAtLoc(SourceLocation Loc,
24  const MatchFinder::MatchResult &MatchResult,
25  IdentifierTable &IdentTable) {
26  Token Tok;
27  if (Lexer::getRawToken(Loc, Tok, *MatchResult.SourceManager,
28  MatchResult.Context->getLangOpts(), false))
29  return Tok;
30 
31  if (Tok.is(tok::raw_identifier)) {
32  IdentifierInfo &Info = IdentTable.get(Tok.getRawIdentifier());
33  Tok.setIdentifierInfo(&Info);
34  Tok.setKind(Info.getTokenID());
35  }
36  return Tok;
37 }
38 
39 namespace tidy {
40 namespace google {
41 namespace runtime {
42 
43 IntegerTypesCheck::IntegerTypesCheck(StringRef Name, ClangTidyContext *Context)
44  : ClangTidyCheck(Name, Context),
45  UnsignedTypePrefix(Options.get("UnsignedTypePrefix", "uint")),
46  SignedTypePrefix(Options.get("SignedTypePrefix", "int")),
47  TypeSuffix(Options.get("TypeSuffix", "")) {}
48 
50  Options.store(Opts, "UnsignedTypePrefix", UnsignedTypePrefix);
51  Options.store(Opts, "SignedTypePrefix", SignedTypePrefix);
52  Options.store(Opts, "TypeSuffix", TypeSuffix);
53 }
54 
55 void IntegerTypesCheck::registerMatchers(MatchFinder *Finder) {
56  // Match any integer types, unless they are passed to a printf-based API:
57  //
58  // http://google.github.io/styleguide/cppguide.html#64-bit_Portability
59  // "Where possible, avoid passing arguments of types specified by
60  // bitwidth typedefs to printf-based APIs."
61  Finder->addMatcher(typeLoc(loc(isInteger()),
62  unless(hasAncestor(callExpr(
63  callee(functionDecl(hasAttr(attr::Format)))))))
64  .bind("tl"),
65  this);
66  IdentTable = std::make_unique<IdentifierTable>(getLangOpts());
67 }
68 
69 void IntegerTypesCheck::check(const MatchFinder::MatchResult &Result) {
70  auto TL = *Result.Nodes.getNodeAs<TypeLoc>("tl");
71  SourceLocation Loc = TL.getBeginLoc();
72 
73  if (Loc.isInvalid() || Loc.isMacroID())
74  return;
75 
76  // Look through qualification.
77  if (auto QualLoc = TL.getAs<QualifiedTypeLoc>())
78  TL = QualLoc.getUnqualifiedLoc();
79 
80  auto BuiltinLoc = TL.getAs<BuiltinTypeLoc>();
81  if (!BuiltinLoc)
82  return;
83 
84  Token Tok = getTokenAtLoc(Loc, Result, *IdentTable);
85  // Ensure the location actually points to one of the builting integral type
86  // names we're interested in. Otherwise, we might be getting this match from
87  // implicit code (e.g. an implicit assignment operator of a class containing
88  // an array of non-POD types).
89  if (!Tok.isOneOf(tok::kw_short, tok::kw_long, tok::kw_unsigned,
90  tok::kw_signed))
91  return;
92 
93  bool IsSigned;
94  unsigned Width;
95  const TargetInfo &TargetInfo = Result.Context->getTargetInfo();
96 
97  // Look for uses of short, long, long long and their unsigned versions.
98  switch (BuiltinLoc.getTypePtr()->getKind()) {
99  case BuiltinType::Short:
100  Width = TargetInfo.getShortWidth();
101  IsSigned = true;
102  break;
103  case BuiltinType::Long:
104  Width = TargetInfo.getLongWidth();
105  IsSigned = true;
106  break;
107  case BuiltinType::LongLong:
108  Width = TargetInfo.getLongLongWidth();
109  IsSigned = true;
110  break;
111  case BuiltinType::UShort:
112  Width = TargetInfo.getShortWidth();
113  IsSigned = false;
114  break;
115  case BuiltinType::ULong:
116  Width = TargetInfo.getLongWidth();
117  IsSigned = false;
118  break;
119  case BuiltinType::ULongLong:
120  Width = TargetInfo.getLongLongWidth();
121  IsSigned = false;
122  break;
123  default:
124  return;
125  }
126 
127  // We allow "unsigned short port" as that's reasonably common and required by
128  // the sockets API.
129  const StringRef Port = "unsigned short port";
130  const char *Data = Result.SourceManager->getCharacterData(Loc);
131  if (!std::strncmp(Data, Port.data(), Port.size()) &&
132  !isAsciiIdentifierContinue(Data[Port.size()]))
133  return;
134 
135  std::string Replacement =
136  ((IsSigned ? SignedTypePrefix : UnsignedTypePrefix) + Twine(Width) +
137  TypeSuffix)
138  .str();
139 
140  // We don't add a fix-it as changing the type can easily break code,
141  // e.g. when a function requires a 'long' argument on all platforms.
142  // QualTypes are printed with implicit quotes.
143  diag(Loc, "consider replacing %0 with '%1'") << BuiltinLoc.getType()
144  << Replacement;
145 }
146 
147 } // namespace runtime
148 } // namespace google
149 } // namespace tidy
150 } // namespace clang
clang::getTokenAtLoc
static Token getTokenAtLoc(SourceLocation Loc, const MatchFinder::MatchResult &MatchResult, IdentifierTable &IdentTable)
Definition: IntegerTypesCheck.cpp:23
Loc
SourceLocation Loc
Definition: KernelNameRestrictionCheck.cpp:45
clang::tidy::ClangTidyOptions::OptionMap
llvm::StringMap< ClangTidyValue > OptionMap
Definition: ClangTidyOptions.h:115
clang::tidy::ClangTidyCheck
Base class for all clang-tidy checks.
Definition: ClangTidyCheck.h:54
clang::tidy::ClangTidyCheck::getLangOpts
const LangOptions & getLangOpts() const
Returns the language options from the context.
Definition: ClangTidyCheck.h:420
clang::tidy::google::runtime::IntegerTypesCheck::registerMatchers
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
Definition: IntegerTypesCheck.cpp:55
clang::tidy::ClangTidyCheck::Options
OptionsView Options
Definition: ClangTidyCheck.h:416
clang::tidy::google::runtime::IntegerTypesCheck::storeOptions
void storeOptions(ClangTidyOptions::OptionMap &Options) override
Should store all options supported by this check with their current values or default values for opti...
Definition: IntegerTypesCheck.cpp:49
clang::tidy::ClangTidyContext
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
Definition: ClangTidyDiagnosticConsumer.h:72
Name
static constexpr llvm::StringLiteral Name
Definition: UppercaseLiteralSuffixCheck.cpp:28
clang::tidy::ClangTidyCheck::diag
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check's name.
Definition: ClangTidyCheck.cpp:25
IntegerTypesCheck.h
Info
FunctionInfo Info
Definition: FunctionSizeCheck.cpp:121
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::tidy::google::runtime::IntegerTypesCheck::check
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
Definition: IntegerTypesCheck.cpp:69
clang::tidy::ClangTidyCheck::OptionsView::store
void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, StringRef Value) const
Stores an option with the check-local name LocalName with string value Value to Options.
Definition: ClangTidyCheck.cpp:120