lib/Format/NamespaceEndCommentsFixer.cpp

   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 // Matches a valid namespace end comment.
  31 // Valid namespace end comments don't need to be edited.
  32 static llvm::Regex kNamespaceCommentPattern =
  33     llvm::Regex("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
  34                 "namespace( +([a-zA-Z0-9:_]+))?\\.? *(\\*/)?$",
  35                 llvm::Regex::IgnoreCase);
  36
  37 // Computes the name of a namespace given the namespace token.
  38 // Returns "" for anonymous namespace.
  39 std::string computeName(const FormatToken *NamespaceTok) {
  40   assert(NamespaceTok && NamespaceTok->is(tok::kw_namespace) &&
  41          "expecting a namespace token");
  42   std::string name = "";
  43   // Collects all the non-comment tokens between 'namespace' and '{'.
  44   const FormatToken *Tok = NamespaceTok->getNextNonComment();
  45   while (Tok && !Tok->is(tok::l_brace)) {
  46     name += Tok->TokenText;
  47     Tok = Tok->getNextNonComment();
  48   }
  49   return name;
  50 }
  51
  52 std::string computeEndCommentText(StringRef NamespaceName, bool AddNewline) {
  53   std::string text = "// namespace";
  54   if (!NamespaceName.empty()) {
  55     text += ' ';
  56     text += NamespaceName;
  57   }
  58   if (AddNewline)
  59     text += '\n';
  60   return text;
  61 }
  62
  63 bool hasEndComment(const FormatToken *RBraceTok) {
  64   return RBraceTok->Next && RBraceTok->Next->is(tok::comment);
  65 }
  66
  67 bool validEndComment(const FormatToken *RBraceTok, StringRef NamespaceName) {
  68   assert(hasEndComment(RBraceTok));
  69   const FormatToken *Comment = RBraceTok->Next;
  70   SmallVector<StringRef, 7> Groups;
  71   if (kNamespaceCommentPattern.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
 111 const FormatToken *
 112 getNamespaceToken(const AnnotatedLine *line,
 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   // Detect "(inline)? namespace" in the beginning of a line.
 122   if (NamespaceTok->is(tok::kw_inline))
 123     NamespaceTok = NamespaceTok->getNextNonComment();
 124   if (!NamespaceTok || NamespaceTok->isNot(tok::kw_namespace))
 125     return nullptr;
 126   return NamespaceTok;
 127 }
 128 } // namespace
 129
 130 NamespaceEndCommentsFixer::NamespaceEndCommentsFixer(const Environment &Env,
 131                                                      const FormatStyle &Style)
 132     : TokenAnalyzer(Env, Style) {}
 133
 134 tooling::Replacements NamespaceEndCommentsFixer::analyze(
 135     TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
 136     FormatTokenLexer &Tokens) {
 137   const SourceManager &SourceMgr = Env.getSourceManager();
 138   AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
 139                                         AnnotatedLines.end());
 140   tooling::Replacements Fixes;
 141   std::string AllNamespaceNames = "";
 142   size_t StartLineIndex = SIZE_MAX;
 143   unsigned int CompactedNamespacesCount = 0;
 144   for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
 145     const AnnotatedLine *EndLine = AnnotatedLines[I];
 146     const FormatToken *NamespaceTok =
 147         getNamespaceToken(EndLine, AnnotatedLines);
 148     if (!NamespaceTok)
 149       continue;
 150     FormatToken *RBraceTok = EndLine->First;
 151     if (RBraceTok->Finalized)
 152       continue;
 153     RBraceTok->Finalized = true;
 154     const FormatToken *EndCommentPrevTok = RBraceTok;
 155     // Namespaces often end with '};'. In that case, attach namespace end
 156     // comments to the semicolon tokens.
 157     if (RBraceTok->Next && RBraceTok->Next->is(tok::semi)) {
 158       EndCommentPrevTok = RBraceTok->Next;
 159     }
 160     if (StartLineIndex == SIZE_MAX)
 161       StartLineIndex = EndLine->MatchingOpeningBlockLineIndex;
 162     std::string NamespaceName = computeName(NamespaceTok);
 163     if (Style.CompactNamespaces) {
 164       if ((I + 1 < E) &&
 165           getNamespaceToken(AnnotatedLines[I + 1], AnnotatedLines) &&
 166           StartLineIndex - CompactedNamespacesCount - 1 ==
 167               AnnotatedLines[I + 1]->MatchingOpeningBlockLineIndex &&
 168           !AnnotatedLines[I + 1]->First->Finalized) {
 169         if (hasEndComment(EndCommentPrevTok)) {
 170           // remove end comment, it will be merged in next one
 171           updateEndComment(EndCommentPrevTok, std::string(), SourceMgr, &Fixes);
 172         }
 173         CompactedNamespacesCount++;
 174         AllNamespaceNames = "::" + NamespaceName + AllNamespaceNames;
 175         continue;
 176       }
 177       NamespaceName += AllNamespaceNames;
 178       CompactedNamespacesCount = 0;
 179       AllNamespaceNames = std::string();
 180     }
 181     // The next token in the token stream after the place where the end comment
 182     // token must be. This is either the next token on the current line or the
 183     // first token on the next line.
 184     const FormatToken *EndCommentNextTok = EndCommentPrevTok->Next;
 185     if (EndCommentNextTok && EndCommentNextTok->is(tok::comment))
 186       EndCommentNextTok = EndCommentNextTok->Next;
 187     if (!EndCommentNextTok && I + 1 < E)
 188       EndCommentNextTok = AnnotatedLines[I + 1]->First;
 189     bool AddNewline = EndCommentNextTok &&
 190                       EndCommentNextTok->NewlinesBefore == 0 &&
 191                       EndCommentNextTok->isNot(tok::eof);
 192     const std::string EndCommentText =
 193         computeEndCommentText(NamespaceName, AddNewline);
 194     if (!hasEndComment(EndCommentPrevTok)) {
 195       bool isShort = I - StartLineIndex <= kShortNamespaceMaxLines + 1;
 196       if (!isShort)
 197         addEndComment(EndCommentPrevTok, EndCommentText, SourceMgr, &Fixes);
 198     } else if (!validEndComment(EndCommentPrevTok, NamespaceName)) {
 199       updateEndComment(EndCommentPrevTok, EndCommentText, SourceMgr, &Fixes);
 200     }
 201     StartLineIndex = SIZE_MAX;
 202   }
 203   return Fixes;
 204 }
 205
 206 } // namespace format
 207 } // namespace clang