llvm-project

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 (const auto *Tok = OperateLine->First;
147
          Tok->is(tok::comment) && !isClangFormatOn(Tok->TokenText)) {
148
        return true;
149
      }
150

151
      // A single line identifier that is not in the last line.
152
      if (OperateLine->First->is(tok::identifier) &&
153
          OperateLine->First == OperateLine->Last &&
154
          OperateIndex + 1 < Lines.size()) {
155
        // UnwrappedLineParser's recognition of free-standing macro like
156
        // Q_OBJECT may also recognize some uppercased type names that may be
157
        // used as return type as that kind of macros, which is a bit hard to
158
        // distinguish one from another purely from token patterns. Here, we
159
        // try not to add new lines below those identifiers.
160
        AnnotatedLine *NextLine = Lines[OperateIndex + 1];
161
        if (NextLine->MightBeFunctionDecl &&
162
            NextLine->mightBeFunctionDefinition() &&
163
            NextLine->First->NewlinesBefore == 1 &&
164
            OperateLine->First->is(TT_FunctionLikeOrFreestandingMacro)) {
165
          return true;
166
        }
167
      }
168

169
      if (Style.isCSharp() && OperateLine->First->is(TT_AttributeSquare))
170
        return true;
171
      return false;
172
    };
173

174
    if (HasEnumOnLine() &&
175
        !LikelyDefinition(CurrentLine, /*ExcludeEnum=*/true)) {
176
      // We have no scope opening/closing information for enum.
177
      IsDefBlock = true;
178
      OpeningLineIndex = I;
179
      while (OpeningLineIndex > 0 && MayPrecedeDefinition())
180
        --OpeningLineIndex;
181
      OpeningLine = Lines[OpeningLineIndex];
182
      TargetLine = OpeningLine;
183
      TargetToken = TargetLine->First;
184
      if (!FollowingOtherOpening())
185
        InsertReplacement(NewlineCount);
186
      else if (IsNeverStyle)
187
        InsertReplacement(OpeningLineIndex != 0);
188
      TargetLine = CurrentLine;
189
      TargetToken = TargetLine->First;
190
      while (TargetToken && TargetToken->isNot(tok::r_brace))
191
        TargetToken = TargetToken->Next;
192
      if (!TargetToken)
193
        while (I < Lines.size() && Lines[I]->First->isNot(tok::r_brace))
194
          ++I;
195
    } else if (CurrentLine->First->closesScope()) {
196
      if (OpeningLineIndex > Lines.size())
197
        continue;
198
      // Handling the case that opening brace has its own line, with checking
199
      // whether the last line already had an opening brace to guard against
200
      // misrecognition.
201
      if (OpeningLineIndex > 0 &&
202
          Lines[OpeningLineIndex]->First->is(tok::l_brace) &&
203
          Lines[OpeningLineIndex - 1]->Last->isNot(tok::l_brace)) {
204
        --OpeningLineIndex;
205
      }
206
      OpeningLine = Lines[OpeningLineIndex];
207
      // Closing a function definition.
208
      if (LikelyDefinition(OpeningLine)) {
209
        IsDefBlock = true;
210
        while (OpeningLineIndex > 0 && MayPrecedeDefinition())
211
          --OpeningLineIndex;
212
        OpeningLine = Lines[OpeningLineIndex];
213
        TargetLine = OpeningLine;
214
        TargetToken = TargetLine->First;
215
        if (!FollowingOtherOpening()) {
216
          // Avoid duplicated replacement.
217
          if (TargetToken->isNot(tok::l_brace))
218
            InsertReplacement(NewlineCount);
219
        } else if (IsNeverStyle) {
220
          InsertReplacement(OpeningLineIndex != 0);
221
        }
222
      }
223
    }
224

225
    // Not the last token.
226
    if (IsDefBlock && I + 1 < Lines.size()) {
227
      OpeningLineIndex = I + 1;
228
      TargetLine = Lines[OpeningLineIndex];
229
      TargetToken = TargetLine->First;
230

231
      // No empty line for continuously closing scopes. The token will be
232
      // handled in another case if the line following is opening a
233
      // definition.
234
      if (!TargetToken->closesScope() && !IsPPConditional(OpeningLineIndex)) {
235
        // Check whether current line may precede a definition line.
236
        while (OpeningLineIndex + 1 < Lines.size() &&
237
               MayPrecedeDefinition(/*Direction=*/0)) {
238
          ++OpeningLineIndex;
239
        }
240
        TargetLine = Lines[OpeningLineIndex];
241
        if (!LikelyDefinition(TargetLine)) {
242
          OpeningLineIndex = I + 1;
243
          TargetLine = Lines[I + 1];
244
          TargetToken = TargetLine->First;
245
          InsertReplacement(NewlineCount);
246
        }
247
      } else if (IsNeverStyle) {
248
        InsertReplacement(/*NewlineToInsert=*/1);
249
      }
250
    }
251
  }
252
  for (const auto &R : Whitespaces.generateReplacements()) {
253
    // The add method returns an Error instance which simulates program exit
254
    // code through overloading boolean operator, thus false here indicates
255
    // success.
256
    if (Result.add(R))
257
      return;
258
  }
259
}
260
} // namespace format
261
} // namespace clang
262