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 /// \brief This file implements NamespaceEndCommentsFixer, a TokenAnalyzer that
12 /// fixes namespace end comments.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #include "NamespaceEndCommentsFixer.h"
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 *
113 getNamespaceToken(const AnnotatedLine *line,
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 
136 NamespaceEndCommentsFixer::NamespaceEndCommentsFixer(const Environment &Env,
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
213