|
150
|
1 //===--- ExplicitConstructorCheck.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 "ExplicitConstructorCheck.h"
|
|
|
10 #include "clang/AST/ASTContext.h"
|
|
|
11 #include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
|
12 #include "clang/ASTMatchers/ASTMatchers.h"
|
|
|
13 #include "clang/Lex/Lexer.h"
|
|
|
14
|
|
|
15 using namespace clang::ast_matchers;
|
|
|
16
|
|
|
17 namespace clang {
|
|
|
18 namespace tidy {
|
|
|
19 namespace google {
|
|
|
20
|
|
|
21 void ExplicitConstructorCheck::registerMatchers(MatchFinder *Finder) {
|
|
|
22 Finder->addMatcher(
|
|
|
23 cxxConstructorDecl(unless(anyOf(isImplicit(), // Compiler-generated.
|
|
|
24 isDeleted(), isInstantiated())))
|
|
|
25 .bind("ctor"),
|
|
|
26 this);
|
|
|
27 Finder->addMatcher(
|
|
|
28 cxxConversionDecl(unless(anyOf(isExplicit(), // Already marked explicit.
|
|
|
29 isImplicit(), // Compiler-generated.
|
|
|
30 isDeleted(), isInstantiated())))
|
|
|
31
|
|
|
32 .bind("conversion"),
|
|
|
33 this);
|
|
|
34 }
|
|
|
35
|
|
|
36 // Looks for the token matching the predicate and returns the range of the found
|
|
|
37 // token including trailing whitespace.
|
|
|
38 static SourceRange FindToken(const SourceManager &Sources,
|
|
|
39 const LangOptions &LangOpts,
|
|
|
40 SourceLocation StartLoc, SourceLocation EndLoc,
|
|
|
41 bool (*Pred)(const Token &)) {
|
|
|
42 if (StartLoc.isMacroID() || EndLoc.isMacroID())
|
|
|
43 return SourceRange();
|
|
|
44 FileID File = Sources.getFileID(Sources.getSpellingLoc(StartLoc));
|
|
|
45 StringRef Buf = Sources.getBufferData(File);
|
|
|
46 const char *StartChar = Sources.getCharacterData(StartLoc);
|
|
|
47 Lexer Lex(StartLoc, LangOpts, StartChar, StartChar, Buf.end());
|
|
|
48 Lex.SetCommentRetentionState(true);
|
|
|
49 Token Tok;
|
|
|
50 do {
|
|
|
51 Lex.LexFromRawLexer(Tok);
|
|
|
52 if (Pred(Tok)) {
|
|
|
53 Token NextTok;
|
|
|
54 Lex.LexFromRawLexer(NextTok);
|
|
|
55 return SourceRange(Tok.getLocation(), NextTok.getLocation());
|
|
|
56 }
|
|
|
57 } while (Tok.isNot(tok::eof) && Tok.getLocation() < EndLoc);
|
|
|
58
|
|
|
59 return SourceRange();
|
|
|
60 }
|
|
|
61
|
|
|
62 static bool declIsStdInitializerList(const NamedDecl *D) {
|
|
|
63 // First use the fast getName() method to avoid unnecessary calls to the
|
|
|
64 // slow getQualifiedNameAsString().
|
|
|
65 return D->getName() == "initializer_list" &&
|
|
|
66 D->getQualifiedNameAsString() == "std::initializer_list";
|
|
|
67 }
|
|
|
68
|
|
|
69 static bool isStdInitializerList(QualType Type) {
|
|
|
70 Type = Type.getCanonicalType();
|
|
|
71 if (const auto *TS = Type->getAs<TemplateSpecializationType>()) {
|
|
|
72 if (const TemplateDecl *TD = TS->getTemplateName().getAsTemplateDecl())
|
|
|
73 return declIsStdInitializerList(TD);
|
|
|
74 }
|
|
|
75 if (const auto *RT = Type->getAs<RecordType>()) {
|
|
|
76 if (const auto *Specialization =
|
|
|
77 dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl()))
|
|
|
78 return declIsStdInitializerList(Specialization->getSpecializedTemplate());
|
|
|
79 }
|
|
|
80 return false;
|
|
|
81 }
|
|
|
82
|
|
|
83 void ExplicitConstructorCheck::check(const MatchFinder::MatchResult &Result) {
|
|
|
84 constexpr char WarningMessage[] =
|
|
|
85 "%0 must be marked explicit to avoid unintentional implicit conversions";
|
|
|
86
|
|
|
87 if (const auto *Conversion =
|
|
|
88 Result.Nodes.getNodeAs<CXXConversionDecl>("conversion")) {
|
|
|
89 if (Conversion->isOutOfLine())
|
|
|
90 return;
|
|
|
91 SourceLocation Loc = Conversion->getLocation();
|
|
|
92 // Ignore all macros until we learn to ignore specific ones (e.g. used in
|
|
|
93 // gmock to define matchers).
|
|
|
94 if (Loc.isMacroID())
|
|
|
95 return;
|
|
|
96 diag(Loc, WarningMessage)
|
|
|
97 << Conversion << FixItHint::CreateInsertion(Loc, "explicit ");
|
|
|
98 return;
|
|
|
99 }
|
|
|
100
|
|
|
101 const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
|
|
|
102 if (Ctor->isOutOfLine() || Ctor->getNumParams() == 0 ||
|
|
|
103 Ctor->getMinRequiredArguments() > 1)
|
|
|
104 return;
|
|
|
105
|
|
|
106 bool takesInitializerList = isStdInitializerList(
|
|
|
107 Ctor->getParamDecl(0)->getType().getNonReferenceType());
|
|
|
108 if (Ctor->isExplicit() &&
|
|
|
109 (Ctor->isCopyOrMoveConstructor() || takesInitializerList)) {
|
|
|
110 auto isKWExplicit = [](const Token &Tok) {
|
|
|
111 return Tok.is(tok::raw_identifier) &&
|
|
|
112 Tok.getRawIdentifier() == "explicit";
|
|
|
113 };
|
|
|
114 SourceRange ExplicitTokenRange =
|
|
|
115 FindToken(*Result.SourceManager, getLangOpts(),
|
|
|
116 Ctor->getOuterLocStart(), Ctor->getEndLoc(), isKWExplicit);
|
|
|
117 StringRef ConstructorDescription;
|
|
|
118 if (Ctor->isMoveConstructor())
|
|
|
119 ConstructorDescription = "move";
|
|
|
120 else if (Ctor->isCopyConstructor())
|
|
|
121 ConstructorDescription = "copy";
|
|
|
122 else
|
|
|
123 ConstructorDescription = "initializer-list";
|
|
|
124
|
|
|
125 auto Diag = diag(Ctor->getLocation(),
|
|
|
126 "%0 constructor should not be declared explicit")
|
|
|
127 << ConstructorDescription;
|
|
|
128 if (ExplicitTokenRange.isValid()) {
|
|
|
129 Diag << FixItHint::CreateRemoval(
|
|
|
130 CharSourceRange::getCharRange(ExplicitTokenRange));
|
|
|
131 }
|
|
|
132 return;
|
|
|
133 }
|
|
|
134
|
|
|
135 if (Ctor->isExplicit() || Ctor->isCopyOrMoveConstructor() ||
|
|
|
136 takesInitializerList)
|
|
|
137 return;
|
|
|
138
|
|
|
139 bool SingleArgument =
|
|
|
140 Ctor->getNumParams() == 1 && !Ctor->getParamDecl(0)->isParameterPack();
|
|
|
141 SourceLocation Loc = Ctor->getLocation();
|
|
|
142 diag(Loc, WarningMessage)
|
|
|
143 << (SingleArgument
|
|
|
144 ? "single-argument constructors"
|
|
|
145 : "constructors that are callable with a single argument")
|
|
|
146 << FixItHint::CreateInsertion(Loc, "explicit ");
|
|
|
147 }
|
|
|
148
|
|
|
149 } // namespace google
|
|
|
150 } // namespace tidy
|
|
|
151 } // namespace clang
|
