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