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 260