clang-tools  7.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->getLocStart(), 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->getLocStart());
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
SourceLocation Loc
&#39;#&#39; location in the include directive
llvm::StringRef Name
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:460
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
Some operations such as code completion produce a set of candidates.
LangOptions getLangOpts() const
Returns the language options from the context.
Definition: ClangTidy.h:187
Base class for all clang-tidy checks.
Definition: ClangTidy.h:127
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
static bool locationsInSameFile(const SourceManager &Sources, SourceLocation Loc1, SourceLocation Loc2)
std::map< std::string, std::string > OptionMap
static std::string getNamespaceComment(const NamespaceDecl *ND, bool InsertLineBreak)
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
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))
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check&#39;s name.
Definition: ClangTidy.cpp:427