clang-tools 8.0.0

NamespaceCommentCheck.cpp
Go to the documentation of this file.
1 //===--- NamespaceCommentCheck.cpp - clang-tidy ---------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "NamespaceCommentCheck.h"
11 #include "clang/AST/ASTContext.h"
12 #include "clang/ASTMatchers/ASTMatchers.h"
13 #include "clang/Lex/Lexer.h"
14 #include "llvm/ADT/StringExtras.h"
15
16 using namespace clang::ast_matchers;
17
18 namespace clang {
19 namespace tidy {
20 namespace readability {
21
22 NamespaceCommentCheck::NamespaceCommentCheck(StringRef Name,
23 ClangTidyContext *Context)
24 : ClangTidyCheck(Name, Context),
25 NamespaceCommentPattern("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
26 "namespace( +([a-zA-Z0-9_:]+))?\\.? *(\\*/)?$",
27 llvm::Regex::IgnoreCase),
28 ShortNamespaceLines(Options.get("ShortNamespaceLines", 1u)),
29 SpacesBeforeComments(Options.get("SpacesBeforeComments", 1u)) {}
30
31 void NamespaceCommentCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
32 Options.store(Opts, "ShortNamespaceLines", ShortNamespaceLines);
33 Options.store(Opts, "SpacesBeforeComments", SpacesBeforeComments);
34 }
35
36 void NamespaceCommentCheck::registerMatchers(MatchFinder *Finder) {
37 // Only register the matchers for C++; the functionality currently does not
38 // provide any benefit to other languages, despite being benign.
39 if (getLangOpts().CPlusPlus)
40 Finder->addMatcher(namespaceDecl().bind("namespace"), this);
41 }
42
43 static bool locationsInSameFile(const SourceManager &Sources,
44 SourceLocation Loc1, SourceLocation Loc2) {
45 return Loc1.isFileID() && Loc2.isFileID() &&
46 Sources.getFileID(Loc1) == Sources.getFileID(Loc2);
47 }
48
49 static std::string getNamespaceComment(const NamespaceDecl *ND,
50 bool InsertLineBreak) {
51 std::string Fix = "// namespace";
52 if (!ND->isAnonymousNamespace())
53 Fix.append(" ").append(ND->getNameAsString());
54 if (InsertLineBreak)
55 Fix.append("\n");
56 return Fix;
57 }
58
59 static std::string getNamespaceComment(const std::string &NameSpaceName,
60 bool InsertLineBreak) {
61 std::string Fix = "// namespace ";
62 Fix.append(NameSpaceName);
63 if (InsertLineBreak)
64 Fix.append("\n");
65 return Fix;
66 }
67
68 void NamespaceCommentCheck::check(const MatchFinder::MatchResult &Result) {
69 const auto *ND = Result.Nodes.getNodeAs<NamespaceDecl>("namespace");
70 const SourceManager &Sources = *Result.SourceManager;
71
72 if (!locationsInSameFile(Sources, ND->getBeginLoc(), ND->getRBraceLoc()))
73 return;
74
75 // Don't require closing comments for namespaces spanning less than certain
76 // number of lines.
77 unsigned StartLine = Sources.getSpellingLineNumber(ND->getBeginLoc());
78 unsigned EndLine = Sources.getSpellingLineNumber(ND->getRBraceLoc());
79 if (EndLine - StartLine + 1 <= ShortNamespaceLines)
80 return;
81
82 // Find next token after the namespace closing brace.
83 SourceLocation AfterRBrace = ND->getRBraceLoc().getLocWithOffset(1);
84 SourceLocation Loc = AfterRBrace;
85 Token Tok;
86 SourceLocation LBracketLocation = ND->getLocation();
87 SourceLocation NestedNamespaceBegin = LBracketLocation;
88
89 // Currently for nested namepsace (n1::n2::...) the AST matcher will match foo
90 // then bar instead of a single match. So if we got a nested namespace we have
91 // to skip the next ones.
92 for (const auto &EndOfNameLocation : Ends) {
93 if (Sources.isBeforeInTranslationUnit(NestedNamespaceBegin,
94 EndOfNameLocation))
95 return;
96 }
97
98 // Ignore macros
99 if (!ND->getLocation().isMacroID()) {
100 while (Lexer::getRawToken(LBracketLocation, Tok, Sources, getLangOpts()) ||
101 !Tok.is(tok::l_brace)) {
102 LBracketLocation = LBracketLocation.getLocWithOffset(1);
103 }
104 }
105
106 auto TextRange =
107 Lexer::getAsCharRange(SourceRange(NestedNamespaceBegin, LBracketLocation),
108 Sources, getLangOpts());
109 StringRef NestedNamespaceName =
110 Lexer::getSourceText(TextRange, Sources, getLangOpts()).rtrim();
111 bool IsNested = NestedNamespaceName.contains(':');
112
113 if (IsNested)
114 Ends.push_back(LBracketLocation);
115 else
116 NestedNamespaceName = ND->getName();
117
118 // Skip whitespace until we find the next token.
119 while (Lexer::getRawToken(Loc, Tok, Sources, getLangOpts()) ||
120 Tok.is(tok::semi)) {
121 Loc = Loc.getLocWithOffset(1);
122 }
123
124 if (!locationsInSameFile(Sources, ND->getRBraceLoc(), Loc))
125 return;
126
127 bool NextTokenIsOnSameLine = Sources.getSpellingLineNumber(Loc) == EndLine;
128 // If we insert a line comment before the token in the same line, we need
129 // to insert a line break.
130 bool NeedLineBreak = NextTokenIsOnSameLine && Tok.isNot(tok::eof);
131
132 SourceRange OldCommentRange(AfterRBrace, AfterRBrace);
133 std::string Message = "%0 not terminated with a closing comment";
134
135 // Try to find existing namespace closing comment on the same line.
136 if (Tok.is(tok::comment) && NextTokenIsOnSameLine) {
137 StringRef Comment(Sources.getCharacterData(Loc), Tok.getLength());
138 SmallVector<StringRef, 7> Groups;
139 if (NamespaceCommentPattern.match(Comment, &Groups)) {
140 StringRef NamespaceNameInComment = Groups.size() > 5 ? Groups[5] : "";
141 StringRef Anonymous = Groups.size() > 3 ? Groups[3] : "";
142
143 if (IsNested && NestedNamespaceName == NamespaceNameInComment) {
144 // C++17 nested namespace.
145 return;
146 } else if ((ND->isAnonymousNamespace() &&
147 NamespaceNameInComment.empty()) ||
148 (ND->getNameAsString() == NamespaceNameInComment &&
149 Anonymous.empty())) {
150 // Check if the namespace in the comment is the same.
151 // FIXME: Maybe we need a strict mode, where we always fix namespace
152 // comments with different format.
153 return;
154 }
155
156 // Otherwise we need to fix the comment.
157 NeedLineBreak = Comment.startswith("/*");
158 OldCommentRange =
159 SourceRange(AfterRBrace, Loc.getLocWithOffset(Tok.getLength()));
160 Message =
161 (llvm::Twine(
162 "%0 ends with a comment that refers to a wrong namespace '") +
163 NamespaceNameInComment + "'")
164 .str();
165 } else if (Comment.startswith("//")) {
166 // Assume that this is an unrecognized form of a namespace closing line
167 // comment. Replace it.
168 NeedLineBreak = false;
169 OldCommentRange =
170 SourceRange(AfterRBrace, Loc.getLocWithOffset(Tok.getLength()));
171 Message = "%0 ends with an unrecognized comment";
172 }
173 // If it's a block comment, just move it to the next line, as it can be
174 // multi-line or there may be other tokens behind it.
175 }
176
177 std::string NamespaceName =
178 ND->isAnonymousNamespace()
179 ? "anonymous namespace"
180 : ("namespace '" + NestedNamespaceName.str() + "'");
181
182 diag(AfterRBrace, Message)
183 << NamespaceName
184 << FixItHint::CreateReplacement(
185 CharSourceRange::getCharRange(OldCommentRange),
186 std::string(SpacesBeforeComments, ' ') +
187 (IsNested
188 ? getNamespaceComment(NestedNamespaceName, NeedLineBreak)
189 : getNamespaceComment(ND, NeedLineBreak)));
190 diag(ND->getLocation(), "%0 starts here", DiagnosticIDs::Note)
191 << NamespaceName;
192 }
193
194 } // namespace readability
195 } // namespace tidy
196 } // namespace clang
Loc
SourceLocation Loc
&#39;#&#39; location in the include directive
Definition: IncludeOrderCheck.cpp:37
clang::ast_matchers
Definition: AbseilMatcher.h:15
clang::tidy::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: ClangTidy.cpp:473
clang::tidy::readability::NamespaceCommentCheck::registerMatchers
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
Definition: NamespaceCommentCheck.cpp:36
llvm
Some operations such as code completion produce a set of candidates.
Definition: YAMLGenerator.cpp:28
clang::tidy::ClangTidyCheck::getLangOpts
LangOptions getLangOpts() const
Returns the language options from the context.
Definition: ClangTidy.h:187
clang::tidy::modernize::Message
static const StringRef Message
Definition: UseTransparentFunctorsCheck.cpp:71
clang::tidy::ClangTidyCheck
Base class for all clang-tidy checks.
Definition: ClangTidy.h:127
clang::tidy::readability::NamespaceCommentCheck::check
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
Definition: NamespaceCommentCheck.cpp:68
clang::tidy::ClangTidyCheck::Options
OptionsView Options
Definition: ClangTidy.h:183
clang::tidy::readability::locationsInSameFile
static bool locationsInSameFile(const SourceManager &Sources, SourceLocation Loc1, SourceLocation Loc2)
Definition: NamespaceCommentCheck.cpp:43
Name
static constexpr llvm::StringLiteral Name
Definition: UppercaseLiteralSuffixCheck.cpp:28
clang::tidy::ClangTidyOptions::OptionMap
std::map< std::string, std::string > OptionMap
Definition: ClangTidyOptions.h:98
Result
llvm::Optional< llvm::Expected< tooling::AtomicChanges > > Result
Definition: ClangdServer.cpp:60
NamespaceCommentCheck.h
clang::tidy::readability::getNamespaceComment
static std::string getNamespaceComment(const NamespaceDecl *ND, bool InsertLineBreak)
Definition: NamespaceCommentCheck.cpp:49
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ChangeNamespace.cpp:18
clang::tidy::ClangTidyContext
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
Definition: ClangTidyDiagnosticConsumer.h:100
Fix
static cl::opt< bool > Fix("fix", cl::desc(R"( Apply suggested fixes. Without -fix-errors clang-tidy will bail out if any compilation errors were found. )"), cl::init(false), cl::cat(ClangTidyCategory))
clang::tidy::ClangTidyCheck::diag
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check&#39;s name.
Definition: ClangTidy.cpp:438