|
150
|
1 //===--- QualifiedAutoCheck.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 "QualifiedAutoCheck.h"
|
|
|
10 #include "../utils/LexerUtils.h"
|
|
|
11 #include "clang/ASTMatchers/ASTMatchers.h"
|
|
|
12 #include "llvm/ADT/Optional.h"
|
|
|
13 #include "llvm/ADT/SmallVector.h"
|
|
|
14
|
|
|
15 using namespace clang::ast_matchers;
|
|
|
16
|
|
|
17 namespace clang {
|
|
|
18 namespace tidy {
|
|
|
19 namespace readability {
|
|
|
20
|
|
|
21 namespace {
|
|
|
22
|
|
|
23 // FIXME move to ASTMatchers
|
|
|
24 AST_MATCHER_P(QualType, hasUnqualifiedType,
|
|
|
25 ast_matchers::internal::Matcher<QualType>, InnerMatcher) {
|
|
|
26 return InnerMatcher.matches(Node.getUnqualifiedType(), Finder, Builder);
|
|
|
27 }
|
|
|
28
|
|
|
29 enum class Qualifier { Const, Volatile, Restrict };
|
|
|
30
|
|
|
31 llvm::Optional<Token> findQualToken(const VarDecl *Decl, Qualifier Qual,
|
|
|
32 const MatchFinder::MatchResult &Result) {
|
|
|
33 // Since either of the locs can be in a macro, use `makeFileCharRange` to be
|
|
|
34 // sure that we have a consistent `CharSourceRange`, located entirely in the
|
|
|
35 // source file.
|
|
|
36
|
|
|
37 assert((Qual == Qualifier::Const || Qual == Qualifier::Volatile ||
|
|
|
38 Qual == Qualifier::Restrict) &&
|
|
|
39 "Invalid Qualifier");
|
|
|
40
|
|
|
41 SourceLocation BeginLoc = Decl->getQualifierLoc().getBeginLoc();
|
|
|
42 if (BeginLoc.isInvalid())
|
|
|
43 BeginLoc = Decl->getBeginLoc();
|
|
|
44 SourceLocation EndLoc = Decl->getLocation();
|
|
|
45
|
|
|
46 CharSourceRange FileRange = Lexer::makeFileCharRange(
|
|
|
47 CharSourceRange::getCharRange(BeginLoc, EndLoc), *Result.SourceManager,
|
|
|
48 Result.Context->getLangOpts());
|
|
|
49
|
|
|
50 if (FileRange.isInvalid())
|
|
|
51 return llvm::None;
|
|
|
52
|
|
|
53 tok::TokenKind Tok =
|
|
|
54 Qual == Qualifier::Const
|
|
|
55 ? tok::kw_const
|
|
|
56 : Qual == Qualifier::Volatile ? tok::kw_volatile : tok::kw_restrict;
|
|
|
57
|
|
|
58 return utils::lexer::getQualifyingToken(Tok, FileRange, *Result.Context,
|
|
|
59 *Result.SourceManager);
|
|
|
60 }
|
|
|
61
|
|
|
62 llvm::Optional<SourceRange>
|
|
|
63 getTypeSpecifierLocation(const VarDecl *Var,
|
|
|
64 const MatchFinder::MatchResult &Result) {
|
|
|
65 SourceRange TypeSpecifier(
|
|
|
66 Var->getTypeSpecStartLoc(),
|
|
|
67 Var->getTypeSpecEndLoc().getLocWithOffset(Lexer::MeasureTokenLength(
|
|
|
68 Var->getTypeSpecEndLoc(), *Result.SourceManager,
|
|
|
69 Result.Context->getLangOpts())));
|
|
|
70
|
|
|
71 if (TypeSpecifier.getBegin().isMacroID() ||
|
|
|
72 TypeSpecifier.getEnd().isMacroID())
|
|
|
73 return llvm::None;
|
|
|
74 return TypeSpecifier;
|
|
|
75 }
|
|
|
76
|
|
|
77 llvm::Optional<SourceRange> mergeReplacementRange(SourceRange &TypeSpecifier,
|
|
|
78 const Token &ConstToken) {
|
|
|
79 if (TypeSpecifier.getBegin().getLocWithOffset(-1) == ConstToken.getEndLoc()) {
|
|
|
80 TypeSpecifier.setBegin(ConstToken.getLocation());
|
|
|
81 return llvm::None;
|
|
|
82 }
|
|
|
83 if (TypeSpecifier.getEnd().getLocWithOffset(1) == ConstToken.getLocation()) {
|
|
|
84 TypeSpecifier.setEnd(ConstToken.getEndLoc());
|
|
|
85 return llvm::None;
|
|
|
86 }
|
|
|
87 return SourceRange(ConstToken.getLocation(), ConstToken.getEndLoc());
|
|
|
88 }
|
|
|
89
|
|
|
90 bool isPointerConst(QualType QType) {
|
|
|
91 QualType Pointee = QType->getPointeeType();
|
|
|
92 assert(!Pointee.isNull() && "can't have a null Pointee");
|
|
|
93 return Pointee.isConstQualified();
|
|
|
94 }
|
|
|
95
|
|
|
96 bool isAutoPointerConst(QualType QType) {
|
|
|
97 QualType Pointee =
|
|
|
98 cast<AutoType>(QType->getPointeeType().getTypePtr())->desugar();
|
|
|
99 assert(!Pointee.isNull() && "can't have a null Pointee");
|
|
|
100 return Pointee.isConstQualified();
|
|
|
101 }
|
|
|
102
|
|
|
103 } // namespace
|
|
|
104
|
|
|
105 void QualifiedAutoCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
|
|
|
106 Options.store(Opts, "AddConstToQualified", AddConstToQualified);
|
|
|
107 }
|
|
|
108
|
|
|
109 void QualifiedAutoCheck::registerMatchers(MatchFinder *Finder) {
|
|
|
110 auto ExplicitSingleVarDecl =
|
|
|
111 [](const ast_matchers::internal::Matcher<VarDecl> &InnerMatcher,
|
|
|
112 llvm::StringRef ID) {
|
|
|
113 return declStmt(
|
|
|
114 unless(isInTemplateInstantiation()),
|
|
|
115 hasSingleDecl(
|
|
|
116 varDecl(unless(isImplicit()), InnerMatcher).bind(ID)));
|
|
|
117 };
|
|
|
118 auto ExplicitSingleVarDeclInTemplate =
|
|
|
119 [](const ast_matchers::internal::Matcher<VarDecl> &InnerMatcher,
|
|
|
120 llvm::StringRef ID) {
|
|
|
121 return declStmt(
|
|
|
122 isInTemplateInstantiation(),
|
|
|
123 hasSingleDecl(
|
|
|
124 varDecl(unless(isImplicit()), InnerMatcher).bind(ID)));
|
|
|
125 };
|
|
|
126
|
|
|
127 auto IsBoundToType = refersToType(equalsBoundNode("type"));
|
|
236
|
128 auto UnlessFunctionType = unless(hasUnqualifiedDesugaredType(functionType()));
|
|
|
129 auto IsAutoDeducedToPointer = [](const auto &...InnerMatchers) {
|
|
|
130 return autoType(hasDeducedType(
|
|
|
131 hasUnqualifiedDesugaredType(pointerType(pointee(InnerMatchers...)))));
|
|
|
132 };
|
|
150
|
133
|
|
|
134 Finder->addMatcher(
|
|
236
|
135 ExplicitSingleVarDecl(hasType(IsAutoDeducedToPointer(UnlessFunctionType)),
|
|
150
|
136 "auto"),
|
|
|
137 this);
|
|
|
138
|
|
|
139 Finder->addMatcher(
|
|
|
140 ExplicitSingleVarDeclInTemplate(
|
|
236
|
141 allOf(hasType(IsAutoDeducedToPointer(
|
|
|
142 hasUnqualifiedType(qualType().bind("type")),
|
|
|
143 UnlessFunctionType)),
|
|
150
|
144 anyOf(hasAncestor(
|
|
|
145 functionDecl(hasAnyTemplateArgument(IsBoundToType))),
|
|
|
146 hasAncestor(classTemplateSpecializationDecl(
|
|
|
147 hasAnyTemplateArgument(IsBoundToType))))),
|
|
|
148 "auto"),
|
|
|
149 this);
|
|
|
150 if (!AddConstToQualified)
|
|
|
151 return;
|
|
|
152 Finder->addMatcher(ExplicitSingleVarDecl(
|
|
|
153 hasType(pointerType(pointee(autoType()))), "auto_ptr"),
|
|
|
154 this);
|
|
|
155 Finder->addMatcher(
|
|
|
156 ExplicitSingleVarDecl(hasType(lValueReferenceType(pointee(autoType()))),
|
|
|
157 "auto_ref"),
|
|
|
158 this);
|
|
|
159 }
|
|
|
160
|
|
|
161 void QualifiedAutoCheck::check(const MatchFinder::MatchResult &Result) {
|
|
|
162 if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("auto")) {
|
|
|
163 SourceRange TypeSpecifier;
|
|
|
164 if (llvm::Optional<SourceRange> TypeSpec =
|
|
|
165 getTypeSpecifierLocation(Var, Result)) {
|
|
|
166 TypeSpecifier = *TypeSpec;
|
|
|
167 } else
|
|
|
168 return;
|
|
|
169
|
|
|
170 llvm::SmallVector<SourceRange, 4> RemoveQualifiersRange;
|
|
|
171 auto CheckQualifier = [&](bool IsPresent, Qualifier Qual) {
|
|
|
172 if (IsPresent) {
|
|
|
173 llvm::Optional<Token> Token = findQualToken(Var, Qual, Result);
|
|
|
174 if (!Token || Token->getLocation().isMacroID())
|
|
|
175 return true; // Disregard this VarDecl.
|
|
|
176 if (llvm::Optional<SourceRange> Result =
|
|
|
177 mergeReplacementRange(TypeSpecifier, *Token))
|
|
|
178 RemoveQualifiersRange.push_back(*Result);
|
|
|
179 }
|
|
|
180 return false;
|
|
|
181 };
|
|
|
182
|
|
|
183 bool IsLocalConst = Var->getType().isLocalConstQualified();
|
|
|
184 bool IsLocalVolatile = Var->getType().isLocalVolatileQualified();
|
|
|
185 bool IsLocalRestrict = Var->getType().isLocalRestrictQualified();
|
|
|
186
|
|
|
187 if (CheckQualifier(IsLocalConst, Qualifier::Const) ||
|
|
|
188 CheckQualifier(IsLocalVolatile, Qualifier::Volatile) ||
|
|
|
189 CheckQualifier(IsLocalRestrict, Qualifier::Restrict))
|
|
|
190 return;
|
|
|
191
|
|
|
192 // Check for bridging the gap between the asterisk and name.
|
|
|
193 if (Var->getLocation() == TypeSpecifier.getEnd().getLocWithOffset(1))
|
|
|
194 TypeSpecifier.setEnd(TypeSpecifier.getEnd().getLocWithOffset(1));
|
|
|
195
|
|
|
196 CharSourceRange FixItRange = CharSourceRange::getCharRange(TypeSpecifier);
|
|
|
197 if (FixItRange.isInvalid())
|
|
|
198 return;
|
|
|
199
|
|
|
200 SourceLocation FixitLoc = FixItRange.getBegin();
|
|
|
201 for (SourceRange &Range : RemoveQualifiersRange) {
|
|
|
202 if (Range.getBegin() < FixitLoc)
|
|
|
203 FixitLoc = Range.getBegin();
|
|
|
204 }
|
|
|
205
|
|
|
206 std::string ReplStr = [&] {
|
|
|
207 llvm::StringRef PtrConst = isPointerConst(Var->getType()) ? "const " : "";
|
|
|
208 llvm::StringRef LocalConst = IsLocalConst ? "const " : "";
|
|
|
209 llvm::StringRef LocalVol = IsLocalVolatile ? "volatile " : "";
|
|
|
210 llvm::StringRef LocalRestrict = IsLocalRestrict ? "__restrict " : "";
|
|
|
211 return (PtrConst + "auto *" + LocalConst + LocalVol + LocalRestrict)
|
|
|
212 .str();
|
|
|
213 }();
|
|
|
214
|
|
|
215 DiagnosticBuilder Diag =
|
|
221
|
216 diag(FixitLoc,
|
|
|
217 "'%select{|const }0%select{|volatile }1%select{|__restrict }2auto "
|
|
|
218 "%3' can be declared as '%4%3'")
|
|
|
219 << IsLocalConst << IsLocalVolatile << IsLocalRestrict << Var->getName()
|
|
|
220 << ReplStr;
|
|
150
|
221
|
|
|
222 for (SourceRange &Range : RemoveQualifiersRange) {
|
|
|
223 Diag << FixItHint::CreateRemoval(CharSourceRange::getCharRange(Range));
|
|
|
224 }
|
|
|
225
|
|
|
226 Diag << FixItHint::CreateReplacement(FixItRange, ReplStr);
|
|
|
227 return;
|
|
|
228 }
|
|
|
229 if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("auto_ptr")) {
|
|
|
230 if (!isPointerConst(Var->getType()))
|
|
|
231 return; // Pointer isn't const, no need to add const qualifier.
|
|
|
232 if (!isAutoPointerConst(Var->getType()))
|
|
236
|
233 return; // Const isn't wrapped in the auto type, so must be declared
|
|
150
|
234 // explicitly.
|
|
|
235
|
|
|
236 if (Var->getType().isLocalConstQualified()) {
|
|
|
237 llvm::Optional<Token> Token =
|
|
|
238 findQualToken(Var, Qualifier::Const, Result);
|
|
|
239 if (!Token || Token->getLocation().isMacroID())
|
|
|
240 return;
|
|
|
241 }
|
|
|
242 if (Var->getType().isLocalVolatileQualified()) {
|
|
|
243 llvm::Optional<Token> Token =
|
|
|
244 findQualToken(Var, Qualifier::Volatile, Result);
|
|
|
245 if (!Token || Token->getLocation().isMacroID())
|
|
|
246 return;
|
|
|
247 }
|
|
|
248 if (Var->getType().isLocalRestrictQualified()) {
|
|
|
249 llvm::Optional<Token> Token =
|
|
|
250 findQualToken(Var, Qualifier::Restrict, Result);
|
|
|
251 if (!Token || Token->getLocation().isMacroID())
|
|
|
252 return;
|
|
|
253 }
|
|
|
254
|
|
|
255 if (llvm::Optional<SourceRange> TypeSpec =
|
|
|
256 getTypeSpecifierLocation(Var, Result)) {
|
|
|
257 if (TypeSpec->isInvalid() || TypeSpec->getBegin().isMacroID() ||
|
|
|
258 TypeSpec->getEnd().isMacroID())
|
|
|
259 return;
|
|
|
260 SourceLocation InsertPos = TypeSpec->getBegin();
|
|
221
|
261 diag(InsertPos,
|
|
|
262 "'auto *%select{|const }0%select{|volatile }1%2' can be declared as "
|
|
|
263 "'const auto *%select{|const }0%select{|volatile }1%2'")
|
|
|
264 << Var->getType().isLocalConstQualified()
|
|
|
265 << Var->getType().isLocalVolatileQualified() << Var->getName()
|
|
|
266 << FixItHint::CreateInsertion(InsertPos, "const ");
|
|
150
|
267 }
|
|
|
268 return;
|
|
|
269 }
|
|
|
270 if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("auto_ref")) {
|
|
|
271 if (!isPointerConst(Var->getType()))
|
|
|
272 return; // Pointer isn't const, no need to add const qualifier.
|
|
|
273 if (!isAutoPointerConst(Var->getType()))
|
|
236
|
274 // Const isn't wrapped in the auto type, so must be declared explicitly.
|
|
150
|
275 return;
|
|
|
276
|
|
|
277 if (llvm::Optional<SourceRange> TypeSpec =
|
|
|
278 getTypeSpecifierLocation(Var, Result)) {
|
|
|
279 if (TypeSpec->isInvalid() || TypeSpec->getBegin().isMacroID() ||
|
|
|
280 TypeSpec->getEnd().isMacroID())
|
|
|
281 return;
|
|
|
282 SourceLocation InsertPos = TypeSpec->getBegin();
|
|
|
283 diag(InsertPos, "'auto &%0' can be declared as 'const auto &%0'")
|
|
|
284 << Var->getName() << FixItHint::CreateInsertion(InsertPos, "const ");
|
|
|
285 }
|
|
|
286 return;
|
|
|
287 }
|
|
|
288 }
|
|
|
289
|
|
|
290 } // namespace readability
|
|
|
291 } // namespace tidy
|
|
|
292 } // namespace clang
|
