clang/lib/Format/DefinitionBlockSeparator.cpp

   1 //===--- DefinitionBlockSeparator.cpp ---------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 ///
   9 /// \file
  10 /// This file implements DefinitionBlockSeparator, a TokenAnalyzer that inserts
  11 /// or removes empty lines separating definition blocks like classes, structs,
  12 /// functions, enums, and namespaces in between.
  13 ///
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "DefinitionBlockSeparator.h"
  17 #include "llvm/Support/Debug.h"
  18 #define DEBUG_TYPE "definition-block-separator"
  19
  20 namespace clang {
  21 namespace format {
  22 std::pair<tooling::Replacements, unsigned> DefinitionBlockSeparator::analyze(
  23     TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
  24     FormatTokenLexer &Tokens) {
  25   assert(Style.SeparateDefinitionBlocks != FormatStyle::SDS_Leave);
  26   AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
  27   tooling::Replacements Result;
  28   separateBlocks(AnnotatedLines, Result, Tokens);
  29   return {Result, 0};
  30 }
  31
  32 void DefinitionBlockSeparator::separateBlocks(
  33     SmallVectorImpl<AnnotatedLine *> &Lines, tooling::Replacements &Result,
  34     FormatTokenLexer &Tokens) {
  35   const bool IsNeverStyle =
  36       Style.SeparateDefinitionBlocks == FormatStyle::SDS_Never;
  37   const AdditionalKeywords &ExtraKeywords = Tokens.getKeywords();
  38   auto GetBracketLevelChange = [](const FormatToken *Tok) {
  39     if (Tok->isOneOf(tok::l_brace, tok::l_paren, tok::l_square))
  40       return 1;
  41     if (Tok->isOneOf(tok::r_brace, tok::r_paren, tok::r_square))
  42       return -1;
  43     return 0;
  44   };
  45   auto LikelyDefinition = [&](const AnnotatedLine *Line,
  46                               bool ExcludeEnum = false) {
  47     if ((Line->MightBeFunctionDecl && Line->mightBeFunctionDefinition()) ||
  48         Line->startsWithNamespace()) {
  49       return true;
  50     }
  51     int BracketLevel = 0;
  52     for (const FormatToken *CurrentToken = Line->First; CurrentToken;
  53          CurrentToken = CurrentToken->Next) {
  54       if (BracketLevel == 0) {
  55         if ((CurrentToken->isOneOf(tok::kw_class, tok::kw_struct,
  56                                    tok::kw_union) ||
  57              (Style.isJavaScript() &&
  58               CurrentToken->is(ExtraKeywords.kw_function)))) {
  59           return true;
  60         }
  61         if (!ExcludeEnum && CurrentToken->is(tok::kw_enum))
  62           return true;
  63       }
  64       BracketLevel += GetBracketLevelChange(CurrentToken);
  65     }
  66     return false;
  67   };
  68   unsigned NewlineCount =
  69       (Style.SeparateDefinitionBlocks == FormatStyle::SDS_Always ? 1 : 0) + 1;
  70   WhitespaceManager Whitespaces(
  71       Env.getSourceManager(), Style,
  72       Style.LineEnding > FormatStyle::LE_CRLF
  73           ? WhitespaceManager::inputUsesCRLF(
  74                 Env.getSourceManager().getBufferData(Env.getFileID()),
  75                 Style.LineEnding == FormatStyle::LE_DeriveCRLF)
  76           : Style.LineEnding == FormatStyle::LE_CRLF);
  77   for (unsigned I = 0; I < Lines.size(); ++I) {
  78     const auto &CurrentLine = Lines[I];
  79     if (CurrentLine->InPPDirective)
  80       continue;
  81     FormatToken *TargetToken = nullptr;
  82     AnnotatedLine *TargetLine;
  83     auto OpeningLineIndex = CurrentLine->MatchingOpeningBlockLineIndex;
  84     AnnotatedLine *OpeningLine = nullptr;
  85     const auto IsAccessSpecifierToken = [](const FormatToken *Token) {
  86       return Token->isAccessSpecifier() || Token->isObjCAccessSpecifier();
  87     };
  88     const auto InsertReplacement = [&](const int NewlineToInsert) {
  89       assert(TargetLine);
  90       assert(TargetToken);
  91
  92       // Do not handle EOF newlines.
  93       if (TargetToken->is(tok::eof))
  94         return;
  95       if (IsAccessSpecifierToken(TargetToken) ||
  96           (OpeningLineIndex > 0 &&
  97            IsAccessSpecifierToken(Lines[OpeningLineIndex - 1]->First))) {
  98         return;
  99       }
 100       if (!TargetLine->Affected)
 101         return;
 102       Whitespaces.replaceWhitespace(*TargetToken, NewlineToInsert,
 103                                     TargetToken->OriginalColumn,
 104                                     TargetToken->OriginalColumn);
 105     };
 106     const auto IsPPConditional = [&](const size_t LineIndex) {
 107       const auto &Line = Lines[LineIndex];
 108       return Line->First->is(tok::hash) && Line->First->Next &&
 109              Line->First->Next->isOneOf(tok::pp_if, tok::pp_ifdef, tok::pp_else,
 110                                         tok::pp_ifndef, tok::pp_elifndef,
 111                                         tok::pp_elifdef, tok::pp_elif,
 112                                         tok::pp_endif);
 113     };
 114     const auto FollowingOtherOpening = [&]() {
 115       return OpeningLineIndex == 0 ||
 116              Lines[OpeningLineIndex - 1]->Last->opensScope() ||
 117              IsPPConditional(OpeningLineIndex - 1);
 118     };
 119     const auto HasEnumOnLine = [&]() {
 120       bool FoundEnumKeyword = false;
 121       int BracketLevel = 0;
 122       for (const FormatToken *CurrentToken = CurrentLine->First; CurrentToken;
 123            CurrentToken = CurrentToken->Next) {
 124         if (BracketLevel == 0) {
 125           if (CurrentToken->is(tok::kw_enum))
 126             FoundEnumKeyword = true;
 127           else if (FoundEnumKeyword && CurrentToken->is(tok::l_brace))
 128             return true;
 129         }
 130         BracketLevel += GetBracketLevelChange(CurrentToken);
 131       }
 132       return FoundEnumKeyword && I + 1 < Lines.size() &&
 133              Lines[I + 1]->First->is(tok::l_brace);
 134     };
 135
 136     bool IsDefBlock = false;
 137     const auto MayPrecedeDefinition = [&](const int Direction = -1) {
 138       assert(Direction >= -1);
 139       assert(Direction <= 1);
 140       const size_t OperateIndex = OpeningLineIndex + Direction;
 141       assert(OperateIndex < Lines.size());
 142       const auto &OperateLine = Lines[OperateIndex];
 143       if (LikelyDefinition(OperateLine))
 144         return false;
 145
 146       if (OperateLine->First->is(tok::comment))
 147         return true;
 148
 149       // A single line identifier that is not in the last line.
 150       if (OperateLine->First->is(tok::identifier) &&
 151           OperateLine->First == OperateLine->Last &&
 152           OperateIndex + 1 < Lines.size()) {
 153         // UnwrappedLineParser's recognition of free-standing macro like
 154         // Q_OBJECT may also recognize some uppercased type names that may be
 155         // used as return type as that kind of macros, which is a bit hard to
 156         // distinguish one from another purely from token patterns. Here, we
 157         // try not to add new lines below those identifiers.
 158         AnnotatedLine *NextLine = Lines[OperateIndex + 1];
 159         if (NextLine->MightBeFunctionDecl &&
 160             NextLine->mightBeFunctionDefinition() &&
 161             NextLine->First->NewlinesBefore == 1 &&
 162             OperateLine->First->is(TT_FunctionLikeOrFreestandingMacro)) {
 163           return true;
 164         }
 165       }
 166
 167       if ((Style.isCSharp() && OperateLine->First->is(TT_AttributeSquare)))
 168         return true;
 169       return false;
 170     };
 171
 172     if (HasEnumOnLine() &&
 173         !LikelyDefinition(CurrentLine, /*ExcludeEnum=*/true)) {
 174       // We have no scope opening/closing information for enum.
 175       IsDefBlock = true;
 176       OpeningLineIndex = I;
 177       while (OpeningLineIndex > 0 && MayPrecedeDefinition())
 178         --OpeningLineIndex;
 179       OpeningLine = Lines[OpeningLineIndex];
 180       TargetLine = OpeningLine;
 181       TargetToken = TargetLine->First;
 182       if (!FollowingOtherOpening())
 183         InsertReplacement(NewlineCount);
 184       else if (IsNeverStyle)
 185         InsertReplacement(OpeningLineIndex != 0);
 186       TargetLine = CurrentLine;
 187       TargetToken = TargetLine->First;
 188       while (TargetToken && !TargetToken->is(tok::r_brace))
 189         TargetToken = TargetToken->Next;
 190       if (!TargetToken)
 191         while (I < Lines.size() && !Lines[I]->First->is(tok::r_brace))
 192           ++I;
 193     } else if (CurrentLine->First->closesScope()) {
 194       if (OpeningLineIndex > Lines.size())
 195         continue;
 196       // Handling the case that opening brace has its own line, with checking
 197       // whether the last line already had an opening brace to guard against
 198       // misrecognition.
 199       if (OpeningLineIndex > 0 &&
 200           Lines[OpeningLineIndex]->First->is(tok::l_brace) &&
 201           Lines[OpeningLineIndex - 1]->Last->isNot(tok::l_brace)) {
 202         --OpeningLineIndex;
 203       }
 204       OpeningLine = Lines[OpeningLineIndex];
 205       // Closing a function definition.
 206       if (LikelyDefinition(OpeningLine)) {
 207         IsDefBlock = true;
 208         while (OpeningLineIndex > 0 && MayPrecedeDefinition())
 209           --OpeningLineIndex;
 210         OpeningLine = Lines[OpeningLineIndex];
 211         TargetLine = OpeningLine;
 212         TargetToken = TargetLine->First;
 213         if (!FollowingOtherOpening()) {
 214           // Avoid duplicated replacement.
 215           if (TargetToken->isNot(tok::l_brace))
 216             InsertReplacement(NewlineCount);
 217         } else if (IsNeverStyle) {
 218           InsertReplacement(OpeningLineIndex != 0);
 219         }
 220       }
 221     }
 222
 223     // Not the last token.
 224     if (IsDefBlock && I + 1 < Lines.size()) {
 225       OpeningLineIndex = I + 1;
 226       TargetLine = Lines[OpeningLineIndex];
 227       TargetToken = TargetLine->First;
 228
 229       // No empty line for continuously closing scopes. The token will be
 230       // handled in another case if the line following is opening a
 231       // definition.
 232       if (!TargetToken->closesScope() && !IsPPConditional(OpeningLineIndex)) {
 233         // Check whether current line may precede a definition line.
 234         while (OpeningLineIndex + 1 < Lines.size() &&
 235                MayPrecedeDefinition(/*Direction=*/0)) {
 236           ++OpeningLineIndex;
 237         }
 238         TargetLine = Lines[OpeningLineIndex];
 239         if (!LikelyDefinition(TargetLine)) {
 240           OpeningLineIndex = I + 1;
 241           TargetLine = Lines[I + 1];
 242           TargetToken = TargetLine->First;
 243           InsertReplacement(NewlineCount);
 244         }
 245       } else if (IsNeverStyle) {
 246         InsertReplacement(/*NewlineToInsert=*/1);
 247       }
 248     }
 249   }
 250   for (const auto &R : Whitespaces.generateReplacements()) {
 251     // The add method returns an Error instance which simulates program exit
 252     // code through overloading boolean operator, thus false here indicates
 253     // success.
 254     if (Result.add(R))
 255       return;
 256   }
 257 }
 258 } // namespace format
 259 } // namespace clang