clang  9.0.0svn
NamespaceEndCommentsFixer.cpp
Go to the documentation of this file.
1 //===--- NamespaceEndCommentsFixer.cpp --------------------------*- C++ -*-===//
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 /// \file
10 /// This file implements NamespaceEndCommentsFixer, a TokenAnalyzer that
11 /// fixes namespace end comments.
12 ///
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/Support/Debug.h"
17 #include "llvm/Support/Regex.h"
18 
19 #define DEBUG_TYPE "namespace-end-comments-fixer"
20 
21 namespace clang {
22 namespace format {
23 
24 namespace {
25 // The maximal number of unwrapped lines that a short namespace spans.
26 // Short namespaces don't need an end comment.
27 static const int kShortNamespaceMaxLines = 1;
28 
29 // Computes the name of a namespace given the namespace token.
30 // Returns "" for anonymous namespace.
31 std::string computeName(const FormatToken *NamespaceTok) {
32  assert(NamespaceTok && NamespaceTok->is(tok::kw_namespace) &&
33  "expecting a namespace token");
34  std::string name = "";
35  // Collects all the non-comment tokens between 'namespace' and '{'.
36  const FormatToken *Tok = NamespaceTok->getNextNonComment();
37  while (Tok && !Tok->is(tok::l_brace)) {
38  name += Tok->TokenText;
39  Tok = Tok->getNextNonComment();
40  }
41  return name;
42 }
43 
44 std::string computeEndCommentText(StringRef NamespaceName, bool AddNewline) {
45  std::string text = "// namespace";
46  if (!NamespaceName.empty()) {
47  text += ' ';
48  text += NamespaceName;
49  }
50  if (AddNewline)
51  text += '\n';
52  return text;
53 }
54 
55 bool hasEndComment(const FormatToken *RBraceTok) {
56  return RBraceTok->Next && RBraceTok->Next->is(tok::comment);
57 }
58 
59 bool validEndComment(const FormatToken *RBraceTok, StringRef NamespaceName) {
60  assert(hasEndComment(RBraceTok));
61  const FormatToken *Comment = RBraceTok->Next;
62 
63  // Matches a valid namespace end comment.
64  // Valid namespace end comments don't need to be edited.
65  static llvm::Regex *const NamespaceCommentPattern =
66  new llvm::Regex("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
67  "namespace( +([a-zA-Z0-9:_]+))?\\.? *(\\*/)?$",
68  llvm::Regex::IgnoreCase);
69  SmallVector<StringRef, 7> Groups;
70  if (NamespaceCommentPattern->match(Comment->TokenText, &Groups)) {
71  StringRef NamespaceNameInComment = Groups.size() > 5 ? Groups[5] : "";
72  // Anonymous namespace comments must not mention a namespace name.
73  if (NamespaceName.empty() && !NamespaceNameInComment.empty())
74  return false;
75  StringRef AnonymousInComment = Groups.size() > 3 ? Groups[3] : "";
76  // Named namespace comments must not mention anonymous namespace.
77  if (!NamespaceName.empty() && !AnonymousInComment.empty())
78  return false;
79  return NamespaceNameInComment == NamespaceName;
80  }
81  return false;
82 }
83 
84 void addEndComment(const FormatToken *RBraceTok, StringRef EndCommentText,
85  const SourceManager &SourceMgr,
86  tooling::Replacements *Fixes) {
87  auto EndLoc = RBraceTok->Tok.getEndLoc();
88  auto Range = CharSourceRange::getCharRange(EndLoc, EndLoc);
89  auto Err = Fixes->add(tooling::Replacement(SourceMgr, Range, EndCommentText));
90  if (Err) {
91  llvm::errs() << "Error while adding namespace end comment: "
92  << llvm::toString(std::move(Err)) << "\n";
93  }
94 }
95 
96 void updateEndComment(const FormatToken *RBraceTok, StringRef EndCommentText,
97  const SourceManager &SourceMgr,
98  tooling::Replacements *Fixes) {
99  assert(hasEndComment(RBraceTok));
100  const FormatToken *Comment = RBraceTok->Next;
101  auto Range = CharSourceRange::getCharRange(Comment->getStartOfNonWhitespace(),
102  Comment->Tok.getEndLoc());
103  auto Err = Fixes->add(tooling::Replacement(SourceMgr, Range, EndCommentText));
104  if (Err) {
105  llvm::errs() << "Error while updating namespace end comment: "
106  << llvm::toString(std::move(Err)) << "\n";
107  }
108 }
109 } // namespace
110 
111 const FormatToken *
113  const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
114  if (!Line->Affected || Line->InPPDirective || !Line->startsWith(tok::r_brace))
115  return nullptr;
116  size_t StartLineIndex = Line->MatchingOpeningBlockLineIndex;
117  if (StartLineIndex == UnwrappedLine::kInvalidIndex)
118  return nullptr;
119  assert(StartLineIndex < AnnotatedLines.size());
120  const FormatToken *NamespaceTok = AnnotatedLines[StartLineIndex]->First;
121  if (NamespaceTok->is(tok::l_brace)) {
122  // "namespace" keyword can be on the line preceding '{', e.g. in styles
123  // where BraceWrapping.AfterNamespace is true.
124  if (StartLineIndex > 0)
125  NamespaceTok = AnnotatedLines[StartLineIndex - 1]->First;
126  }
127  return NamespaceTok->getNamespaceToken();
128 }
129 
131  const FormatStyle &Style)
132  : TokenAnalyzer(Env, Style) {}
133 
134 std::pair<tooling::Replacements, unsigned> NamespaceEndCommentsFixer::analyze(
135  TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
136  FormatTokenLexer &Tokens) {
137  const SourceManager &SourceMgr = Env.getSourceManager();
138  AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
139  tooling::Replacements Fixes;
140  std::string AllNamespaceNames = "";
141  size_t StartLineIndex = SIZE_MAX;
142  unsigned int CompactedNamespacesCount = 0;
143  for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
144  const AnnotatedLine *EndLine = AnnotatedLines[I];
145  const FormatToken *NamespaceTok =
146  getNamespaceToken(EndLine, AnnotatedLines);
147  if (!NamespaceTok)
148  continue;
149  FormatToken *RBraceTok = EndLine->First;
150  if (RBraceTok->Finalized)
151  continue;
152  RBraceTok->Finalized = true;
153  const FormatToken *EndCommentPrevTok = RBraceTok;
154  // Namespaces often end with '};'. In that case, attach namespace end
155  // comments to the semicolon tokens.
156  if (RBraceTok->Next && RBraceTok->Next->is(tok::semi)) {
157  EndCommentPrevTok = RBraceTok->Next;
158  }
159  if (StartLineIndex == SIZE_MAX)
160  StartLineIndex = EndLine->MatchingOpeningBlockLineIndex;
161  std::string NamespaceName = computeName(NamespaceTok);
162  if (Style.CompactNamespaces) {
163  if ((I + 1 < E) &&
164  getNamespaceToken(AnnotatedLines[I + 1], AnnotatedLines) &&
165  StartLineIndex - CompactedNamespacesCount - 1 ==
166  AnnotatedLines[I + 1]->MatchingOpeningBlockLineIndex &&
167  !AnnotatedLines[I + 1]->First->Finalized) {
168  if (hasEndComment(EndCommentPrevTok)) {
169  // remove end comment, it will be merged in next one
170  updateEndComment(EndCommentPrevTok, std::string(), SourceMgr, &Fixes);
171  }
172  CompactedNamespacesCount++;
173  AllNamespaceNames = "::" + NamespaceName + AllNamespaceNames;
174  continue;
175  }
176  NamespaceName += AllNamespaceNames;
177  CompactedNamespacesCount = 0;
178  AllNamespaceNames = std::string();
179  }
180  // The next token in the token stream after the place where the end comment
181  // token must be. This is either the next token on the current line or the
182  // first token on the next line.
183  const FormatToken *EndCommentNextTok = EndCommentPrevTok->Next;
184  if (EndCommentNextTok && EndCommentNextTok->is(tok::comment))
185  EndCommentNextTok = EndCommentNextTok->Next;
186  if (!EndCommentNextTok && I + 1 < E)
187  EndCommentNextTok = AnnotatedLines[I + 1]->First;
188  bool AddNewline = EndCommentNextTok &&
189  EndCommentNextTok->NewlinesBefore == 0 &&
190  EndCommentNextTok->isNot(tok::eof);
191  const std::string EndCommentText =
192  computeEndCommentText(NamespaceName, AddNewline);
193  if (!hasEndComment(EndCommentPrevTok)) {
194  bool isShort = I - StartLineIndex <= kShortNamespaceMaxLines + 1;
195  if (!isShort)
196  addEndComment(EndCommentPrevTok, EndCommentText, SourceMgr, &Fixes);
197  } else if (!validEndComment(EndCommentPrevTok, NamespaceName)) {
198  updateEndComment(EndCommentPrevTok, EndCommentText, SourceMgr, &Fixes);
199  }
200  StartLineIndex = SIZE_MAX;
201  }
202  return {Fixes, 0};
203 }
204 
205 } // namespace format
206 } // namespace clang
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
NamespaceEndCommentsFixer(const Environment &Env, const FormatStyle &Style)
const FormatToken * getNextNonComment() const
Returns the next token ignoring comments.
Definition: FormatToken.h:484
Maintains a set of replacements that are conflict-free.
Definition: Replacement.h:209
AffectedRangeManager AffectedRangeMgr
unsigned NewlinesBefore
The number of newlines immediately before the Token.
Definition: FormatToken.h:137
FormatToken * Next
The next token in the unwrapped line.
Definition: FormatToken.h:296
const Environment & Env
Definition: TokenAnalyzer.h:98
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
const FormatToken * getNamespaceToken(const AnnotatedLine *Line, const SmallVectorImpl< AnnotatedLine *> &AnnotatedLines)
bool isNot(T Kind) const
Definition: FormatToken.h:326
const FormatToken & Tok
const SourceManager & getSourceManager() const
Definition: TokenAnalyzer.h:49
Determines extra information about the tokens comprising an UnwrappedLine.
const AnnotatedLine * Line
static const size_t kInvalidIndex
A wrapper around a Token storing information about the whitespace characters preceding it...
Definition: FormatToken.h:127
bool Affected
True if this line should be formatted, i.e.
static CharSourceRange getCharRange(SourceRange R)
std::pair< tooling::Replacements, unsigned > analyze(TokenAnnotator &Annotator, SmallVectorImpl< AnnotatedLine *> &AnnotatedLines, FormatTokenLexer &Tokens) override
bool is(tok::TokenKind Kind) const
Definition: FormatToken.h:310
bool startsWith(Ts... Tokens) const
true if this line starts with the given tokens in order, ignoring comments.
StringRef TokenText
The raw text of the token.
Definition: FormatToken.h:175
#define SIZE_MAX
Definition: stdint.h:648
The FormatStyle is used to configure the formatting to follow specific guidelines.
Definition: Format.h:49
bool computeAffectedLines(SmallVectorImpl< AnnotatedLine *> &Lines)
Dataflow Directional Tag Classes.
bool Finalized
If true, this token has been fully formatted (indented and potentially re-formatted inside)...
Definition: FormatToken.h:308
This file declares NamespaceEndCommentsFixer, a TokenAnalyzer that fixes namespace end comments...
This class handles loading and caching of source files into memory.
const FormatStyle & Style