contrib/llvm/tools/clang/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 } // namespace
 111
 112 NamespaceEndCommentsFixer::NamespaceEndCommentsFixer(const Environment &Env,
 113                                                      const FormatStyle &Style)
 114     : TokenAnalyzer(Env, Style) {}
 115
 116 tooling::Replacements NamespaceEndCommentsFixer::analyze(
 117     TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
 118     FormatTokenLexer &Tokens) {
 119   const SourceManager &SourceMgr = Env.getSourceManager();
 120   AffectedRangeMgr.computeAffectedLines(AnnotatedLines.begin(),
 121                                         AnnotatedLines.end());
 122   tooling::Replacements Fixes;
 123   for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
 124     if (!AnnotatedLines[I]->Affected || AnnotatedLines[I]->InPPDirective ||
 125         !AnnotatedLines[I]->startsWith(tok::r_brace))
 126       continue;
 127     const AnnotatedLine *EndLine = AnnotatedLines[I];
 128     size_t StartLineIndex = EndLine->MatchingOpeningBlockLineIndex;
 129     if (StartLineIndex == UnwrappedLine::kInvalidIndex)
 130       continue;
 131     assert(StartLineIndex < E);
 132     const FormatToken *NamespaceTok = AnnotatedLines[StartLineIndex]->First;
 133     // Detect "(inline)? namespace" in the beginning of a line.
 134     if (NamespaceTok->is(tok::kw_inline))
 135       NamespaceTok = NamespaceTok->getNextNonComment();
 136     if (!NamespaceTok || NamespaceTok->isNot(tok::kw_namespace))
 137       continue;
 138     FormatToken *RBraceTok = EndLine->First;
 139     if (RBraceTok->Finalized)
 140       continue;
 141     RBraceTok->Finalized = true;
 142     const FormatToken *EndCommentPrevTok = RBraceTok;
 143     // Namespaces often end with '};'. In that case, attach namespace end
 144     // comments to the semicolon tokens.
 145     if (RBraceTok->Next && RBraceTok->Next->is(tok::semi)) {
 146       EndCommentPrevTok = RBraceTok->Next;
 147     }
 148     // The next token in the token stream after the place where the end comment
 149     // token must be. This is either the next token on the current line or the
 150     // first token on the next line.
 151     const FormatToken *EndCommentNextTok = EndCommentPrevTok->Next;
 152     if (EndCommentNextTok && EndCommentNextTok->is(tok::comment))
 153       EndCommentNextTok = EndCommentNextTok->Next;
 154     if (!EndCommentNextTok && I + 1 < E)
 155       EndCommentNextTok = AnnotatedLines[I + 1]->First;
 156     bool AddNewline = EndCommentNextTok &&
 157                       EndCommentNextTok->NewlinesBefore == 0 &&
 158                       EndCommentNextTok->isNot(tok::eof);
 159     const std::string NamespaceName = computeName(NamespaceTok);
 160     const std::string EndCommentText =
 161         computeEndCommentText(NamespaceName, AddNewline);
 162     if (!hasEndComment(EndCommentPrevTok)) {
 163       bool isShort = I - StartLineIndex <= kShortNamespaceMaxLines + 1;
 164       if (!isShort)
 165         addEndComment(EndCommentPrevTok, EndCommentText, SourceMgr, &Fixes);
 166       continue;
 167     }
 168     if (!validEndComment(EndCommentPrevTok, NamespaceName))
 169       updateEndComment(EndCommentPrevTok, EndCommentText, SourceMgr, &Fixes);
 170   }
 171   return Fixes;
 172 }
 173
 174 } // namespace format
 175 } // namespace clang