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 /// 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