[clang-format] Add a new extra command line option for ide-specific formatting

[yvvan]

Summary

In order to use clang-format for formatting/indenting code in IDE we need to add some tricks which are never needed for clang-format itself.

Let's start with the option which keeps all existing line breaks when the flag is set. This option is available with extra parameter for reformat() function.

The next steps could be for example - adding dummy text to empty lines to indent them or applying format only for the code before the cursor (for incomplete code). There are much more tricks which could also be considered later.

[krasimir]

In general there's a high bar for adding new style options to clang-format:
https://clang.llvm.org/docs/ClangFormatStyleOptions.html#adding-additional-style-options

[yvvan]

Do you know the better way to accomplish my aim than adding an option to libFormat? For example making a dependent library which serves a little different purpose than libFormat itself or something simpler?

[krasimir]

In D53072#1268883, @yvvan wrote:

Do you know the better way to accomplish my aim than adding an option to libFormat? For example making a dependent library which serves a little different purpose than libFormat itself or something simpler?

I don't know about the specific use-case, but in general a fail-safe way to force a line break in C++ code is to add an empty line comment on the preceding line.

[djasper]

I don't quite understand. What you are describing should already be the behavior with ColumnLimit=0 and I think your test should pass without the new option. Doesn't it?

[yvvan]

In D53072#1342363, @djasper wrote:

I don't quite understand. What you are describing should already be the behavior with ColumnLimit=0 and I think your test should pass without the new option. Doesn't it?

As far as I see how it works column limit does not prevent the shrinking behavior.

In D53072#1342353, @krasimir wrote:

In D53072#1268883, @yvvan wrote:

Do you know the better way to accomplish my aim than adding an option to libFormat? For example making a dependent library which serves a little different purpose than libFormat itself or something simpler?

I don't know about the specific use-case, but in general a fail-safe way to force a line break in C++ code is to add an empty line comment on the preceding line.

This is close but will not work for the case when more than two lines are packed together. So it requires to put the empty comment on the each line ending which is not too nice (if i'm not missing something)

[djasper]

$ cat /tmp/test.cc
int foo(int a,
           int b) {
      f();
  }

$ clang-format -style="{ColumnLimit: 0}" /tmp/test.cc
int foo(int a,
        int b) {
  f();
}

Is this not what you want? If so, in what way?

[yvvan]

In D53072#1348033, @djasper wrote:

$ cat /tmp/test.cc
int foo(int a,
           int b) {
      f();
  }

$ clang-format -style="{ColumnLimit: 0}" /tmp/test.cc
int foo(int a,
        int b) {
  f();
}

Is this not what you want? If so, in what way?

Ok, this might mean that my test is bad and does not test what I want (there are more cases which are not formatted the way I want with ColumnLimit: 0). But since the patch is never to be submitted I don't see a reason to improve it.

[djasper]

Without understanding this in more detail I do not know how to move forward with this. What this patch is describing is what should already be the case with ColumnLimit set to zero. If it isn't this might be a bug or there might be a different way to move forward. However, the flag as is does not make sense to me without more information.

[yvvan]

@djasper
Ok, if there's a possible way to go forward I will find time to provide a better test which behaves differently depending on this check. Also my current patch is a bit bigger than this version.

[yvvan]

The tests are improved - now they actually act differently with and without the introduced flag. Also few more cases are covered (see the second added test).

[djasper]

Ok, but this behavior is still intended. You are setting clang-format to a format where it is breaking after binary operators and then added a break before a binary operator. clang-format assumes that this is not intended and that you will want this cleaned up.

E.g.:

$ cat /tmp/format.cc
if ( a
      && b) {
}

$ clang-format -style="{ColumnLimit: 0, BreakBeforeBinaryOperators: All}" /tmp/format.cc
if (a
    && b) {
}

$ clang-format -style="{ColumnLimit: 0}" /tmp/format.cc
if (a && b) {
}

I believe that this behavior is right and we should not work around it with an additional flag.

[yvvan]

New approach - title and summary are updated.

[sammccall]

You may be interested in D60605, which is a related idea (adding incremental format-and-indent-on-type to clangd).

These are opposite extremes in some sense: this patch integrates deeply into clang-format and that patch entirely layers on top of it, by transforming the source code (in hacky ways, in some cases).

I think the cleanest approach is probably some combination: in particular a "preserve line break at point" primitive does seem useful, and even if source code transforms are used, putting a nice API on this in clang-format would be nice. (I'm not sure a separate command-line-tool is justified, though).

If you haven't run into these yet, here are some fun issues I ran into:

• clang-format bails out when brackets aren't sufficiently matched, incremental formatting needs to work in such cases
• incremental formatting sometimes wants to make edits both immediately before and after the cursor. tooling::Replacements can't represent this, they will be merged and destroy precise cursor position information.
• user expectations when breaking between () are fairly clear. {} is the same when it acts as a list, but not when it acts as a block!

[yvvan]

@sammccall

Having a separate tool is nice because it allows the client to make it plugable. clang-format sometimes changes options quite significantly and it can be nice if you have a choice which version to pick, otherwise it might be unable to read the configuration you have.

[ilya-biryukov]

In D53072#1478575, @yvvan wrote:

@sammccall

Having a separate tool is nice because it allows the client to make it plugable. clang-format sometimes changes options quite significantly and it can be nice if you have a choice which version to pick, otherwise it might be unable to read the configuration you have.

I second Sam's concerns about introducing a new tool.
Could you list the use-cases that clang-format-ide would cover that clang-format doesn't?
How is introducing a new tool different from adding a new formatting option to clang-format?

[yvvan]

@ilya-biryukov
I don't really care how it's used from the tool side. I'm also fine to have a new option in clang-format itself. That's why this review is here - to ask for opinions. It's easy to remove that "ide" part from this patch and just add an option for clang-format instead.
Do you have any other remarks/concerns apart from that?

[sammccall]

My feedback would be:

• I definitely think more control over preserving line breaks would be useful. Actually preserving *blank* lines is an important property. If you see D60605, there are a lot of cases where clang-format wants to delete the line you just added. Maybe we can make MaxEmptyLinesToKeep: 9999999 work in more cases.
• I'm not convinced you need/want to preserve *all* line breaks, isn't it just one? (where the user pressed enter)
• It's unclear why "extraformattingoptions" is needed, rather than just the usual formatting options, or some other parameter. It would be nice to avoid a new library entry point (overload) if possible.
• as far as command-line interface goes, this definitely feels more like a flag than a new tool

[yvvan]

In D53072#1496317, @sammccall wrote:

My feedback would be:

• I definitely think more control over preserving line breaks would be useful. Actually preserving *blank* lines is an important property. If you see D60605, there are a lot of cases where clang-format wants to delete the line you just added. Maybe we can make MaxEmptyLinesToKeep: 9999999 work in more cases.
• I'm not convinced you need/want to preserve *all* line breaks, isn't it just one? (where the user pressed enter)
• It's unclear why "extraformattingoptions" is needed, rather than just the usual formatting options, or some other parameter. It would be nice to avoid a new library entry point (overload) if possible.
• as far as command-line interface goes, this definitely feels more like a flag than a new tool

Thanks for the feedback!
'to preserve *all* line breaks, isn't it just one' - it's just much easier code wise, you don't need to take the current position into account. I can look how I can make it for only one line.
'unclear why "extraformattingoptions" is needed' - the idea behind is that we can add more ide-specific options later without introducing new reformat parameters.
I will definitely remove a separate tool, it seems nobody sees the need of such thing.

[yvvan]

@sammccall
I can't avoid adding extra formatting options because my first attempt to introduce an ordinary clang-format option faced resistance because of not fitting the clang-format purpose to format files.

[yvvan]

Sorry for unrelated formatting changes - that's clang-format's work :)

I've removed the extra executable.

I don't know how to force that behavior only for the given line (for that I need someone who can help) but in our usecase we should not care if we apply the rule to the whole file or only to the current line since we are only interested in one single Replacement which we can anyways filter afterwards.

[yvvan]

Some misleading reformatting fixed.

clang/include/clang/Format/Format.h

struct FormatStyle {
   ///    aaaa =                         vs.     aaaa = "bbbb"
   ///        "bbbb"                                    "cccc";
   ///        "cccc";
   /// \endcode
   bool AlwaysBreakBeforeMultilineStrings;
 
   /// Different ways to break after the template declaration.
   enum BreakTemplateDeclarationsStyle {
-      /// Do not force break before declaration.
-      /// ``PenaltyBreakTemplateDeclaration`` is taken into account.
-      /// \code
-      ///    template <typename T> T foo() {
-      ///    }
-      ///    template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa,
-      ///                                int bbbbbbbbbbbbbbbbbbbbb) {
-      ///    }
-      /// \endcode
-      BTDS_No,
-      /// Force break after template declaration only when the following
-      /// declaration spans multiple lines.
-      /// \code
-      ///    template <typename T> T foo() {
-      ///    }
-      ///    template <typename T>
-      ///    T foo(int aaaaaaaaaaaaaaaaaaaaa,
-      ///          int bbbbbbbbbbbbbbbbbbbbb) {
-      ///    }
-      /// \endcode
-      BTDS_MultiLine,
-      /// Always break after template declaration.
-      /// \code
-      ///    template <typename T>
-      ///    T foo() {
-      ///    }
-      ///    template <typename T>
-      ///    T foo(int aaaaaaaaaaaaaaaaaaaaa,
-      ///          int bbbbbbbbbbbbbbbbbbbbb) {
-      ///    }
-      /// \endcode
-      BTDS_Yes
   };
 
   /// The template declaration breaking style to use.
   BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations;
 
   /// If ``false``, a function call's arguments will either be all on the
   /// same line or will have one line each.
   /// \code
struct FormattingAttemptStatus {
   bool FormatComplete = true;
 
   /// If ``FormatComplete`` is false, ``Line`` records a one-based
   /// original line number at which a syntax error might have occurred. This is
   /// based on a best-effort analysis and could be imprecise.
   unsigned Line = 0;
 };
 
+enum class ExtraFormattingOptions {
+  None = 0x0,
+  KeepLineBreaksForNonEmptyLines = 0x1
+};
+
+inline ExtraFormattingOptions operator|(ExtraFormattingOptions lhs,
+                                        ExtraFormattingOptions rhs) {
+  using T = std::underlying_type_t<ExtraFormattingOptions>;
+  return static_cast<ExtraFormattingOptions>(static_cast<T>(lhs) |
+                                             static_cast<T>(rhs));
+}
+
+inline ExtraFormattingOptions operator&(ExtraFormattingOptions lhs,
+                                        ExtraFormattingOptions rhs) {
+  using T = std::underlying_type_t<ExtraFormattingOptions>;
+  return static_cast<ExtraFormattingOptions>(static_cast<T>(lhs) &
+                                             static_cast<T>(rhs));
+}
+
+inline bool alwaysKeepLineBreaks(ExtraFormattingOptions FormattingOptions) {
+  return (FormattingOptions &
+          ExtraFormattingOptions::KeepLineBreaksForNonEmptyLines) !=
+         ExtraFormattingOptions::None;
+}
+
 /// Reformats the given \p Ranges in \p Code.
 ///
 /// Each range is extended on either end to its next bigger logic unit, i.e.
 /// everything that might influence its formatting or might be influenced by its
 /// formatting.
 ///
 /// Returns the ``Replacements`` necessary to make all \p Ranges comply with
 /// \p Style.
 ///
 /// If ``Status`` is non-null, its value will be populated with the status of
 /// this formatting attempt. See \c FormattingAttemptStatus.
 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName = "<stdin>",
                                FormattingAttemptStatus *Status = nullptr);
 
 /// Same as above, except if ``IncompleteFormat`` is non-null, its value
 /// will be set to true if any of the affected ranges were not formatted due to
 /// a non-recoverable syntax error.
 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
-                               StringRef FileName,
-                               bool *IncompleteFormat);
+                               StringRef FileName, bool *IncompleteFormat);
+
+tooling::Replacements reformat(const FormatStyle &Style,
+                               ExtraFormattingOptions FormattingOptions,
+                               StringRef Code, ArrayRef<tooling::Range> Ranges,
+                               StringRef FileName = "<stdin>",
+                               FormattingAttemptStatus *Status = nullptr);
 
 /// Clean up any erroneous/redundant code in the given \p Ranges in \p
 /// Code.
 ///
 /// Returns the ``Replacements`` that clean up all \p Ranges in \p Code.
 tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
                               ArrayRef<tooling::Range> Ranges,
                               StringRef FileName = "<stdin>");

 }
 
 } // end namespace format
 } // end namespace clang
 
 namespace std {
 template <>
 struct is_error_code_enum<clang::format::ParseError> : std::true_type {};
-}
+} // namespace std
 
 #endif // LLVM_CLANG_FORMAT_FORMAT_H

clang/lib/Format/ContinuationIndenter.cpp

unsigned ContinuationIndenter::reformatRawStringLiteral(
   //   - if the raw string prefix does not start on a newline, it is the current
   //     indent.
   unsigned LastStartColumn =
       Current.NewlinesBefore ? FirstStartColumn - NewPrefixSize : CurrentIndent;
 
   std::pair<tooling::Replacements, unsigned> Fixes = internal::reformat(
       RawStringStyle, RawText, {tooling::Range(0, RawText.size())},
       FirstStartColumn, NextStartColumn, LastStartColumn, "<stdin>",
+      ExtraFormattingOptions::None,
       /*Status=*/nullptr);
 
   auto NewCode = applyAllReplacements(RawText, Fixes.first);
   tooling::Replacements NoFixes;
   if (!NewCode) {
     return addMultilineToken(Current, State);
   }
   if (!DryRun) {

clang/lib/Format/Format.cpp

std::string ParseErrorCategory::message(int EV) const {
   llvm_unreachable("unexpected parse error");
 }
 
 static FormatStyle expandPresets(const FormatStyle &Style) {
   if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
     return Style;
   FormatStyle Expanded = Style;
   Expanded.BraceWrapping = {false, false, false, false, false, false,
-                            false, false, false, false, false,
-                            false, false, true,  true,  true};
+                            false, false, false, false, false, false,
+                            false, true,  true,  true};
   switch (Style.BreakBeforeBraces) {
   case FormatStyle::BS_Linux:
     Expanded.BraceWrapping.AfterClass = true;
     Expanded.BraceWrapping.AfterFunction = true;
     Expanded.BraceWrapping.AfterNamespace = true;
     break;
   case FormatStyle::BS_Mozilla:
     Expanded.BraceWrapping.AfterClass = true;
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.AlwaysBreakBeforeMultilineStrings = false;
   LLVMStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_MultiLine;
   LLVMStyle.BinPackArguments = true;
   LLVMStyle.BinPackParameters = true;
   LLVMStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
   LLVMStyle.BreakBeforeTernaryOperators = true;
   LLVMStyle.BreakBeforeBraces = FormatStyle::BS_Attach;
   LLVMStyle.BraceWrapping = {false, false, false, false, false, false,
-                             false, false, false, false, false,
-                             false, false, true,  true,  true};
+                             false, false, false, false, false, false,
+                             false, true,  true,  true};
   LLVMStyle.BreakAfterJavaFieldAnnotations = false;
   LLVMStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
   LLVMStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
   LLVMStyle.BreakStringLiterals = true;
   LLVMStyle.ColumnLimit = 80;
   LLVMStyle.CommentPragmas = "^ IWYU pragma:";
   LLVMStyle.CompactNamespaces = false;
   LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
for (AnnotatedLine *Line : Lines) {
       }
     }
   }
 };
 
 class Formatter : public TokenAnalyzer {
 public:
   Formatter(const Environment &Env, const FormatStyle &Style,
+            ExtraFormattingOptions FormattingOptions,
             FormattingAttemptStatus *Status)
-      : TokenAnalyzer(Env, Style), Status(Status) {}
+      : TokenAnalyzer(Env, Style, FormattingOptions), Status(Status) {}
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) override {
     tooling::Replacements Result;
     deriveLocalStyle(AnnotatedLines);
     AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
       Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
     }
     Annotator.setCommentLineLevels(AnnotatedLines);
 
     WhitespaceManager Whitespaces(
         Env.getSourceManager(), Style,
         inputUsesCRLF(Env.getSourceManager().getBufferData(Env.getFileID())));
     ContinuationIndenter Indenter(Style, Tokens.getKeywords(),
                                   Env.getSourceManager(), Whitespaces, Encoding,
                                   BinPackInconclusiveFunctions);
     unsigned Penalty =
         UnwrappedLineFormatter(&Indenter, &Whitespaces, Style,
                                Tokens.getKeywords(), Env.getSourceManager(),
-                               Status)
+                               FormattingOptions, Status)
             .format(AnnotatedLines, /*DryRun=*/false,
                     /*AdditionalIndent=*/0,
                     /*FixBadIndentation=*/false,
                     /*FirstStartColumn=*/Env.getFirstStartColumn(),
                     /*NextStartColumn=*/Env.getNextStartColumn(),
                     /*LastStartColumn=*/Env.getLastStartColumn());
     for (const auto &R : Whitespaces.generateReplacements())
       if (Result.add(R))

 // source order.
 // #include directives with the same text will be deduplicated, and only the
 // first #include in the duplicate #includes remains. If the `Cursor` is
 // provided and put on a deleted #include, it will be moved to the remaining
 // #include in the duplicate #includes.
 static void sortCppIncludes(const FormatStyle &Style,
                             const SmallVectorImpl<IncludeDirective> &Includes,
                             ArrayRef<tooling::Range> Ranges, StringRef FileName,
-                            StringRef Code,
-                            tooling::Replacements &Replaces, unsigned *Cursor) {
+                            StringRef Code, tooling::Replacements &Replaces,
+                            unsigned *Cursor) {
   unsigned IncludesBeginOffset = Includes.front().Offset;
   unsigned IncludesEndOffset =
       Includes.back().Offset + Includes.back().Text.size();
   unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
   if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
     return;
   SmallVector<unsigned, 16> Indices;
   for (unsigned i = 0, e = Includes.size(); i != e; ++i)
cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
   return processReplacements(Cleanup, Code, NewReplaces, Style);
 }
 
 namespace internal {
 std::pair<tooling::Replacements, unsigned>
 reformat(const FormatStyle &Style, StringRef Code,
          ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
          unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName,
+         ExtraFormattingOptions FormattingOptions,
          FormattingAttemptStatus *Status) {
   FormatStyle Expanded = expandPresets(Style);
   if (Expanded.DisableFormat)
     return {tooling::Replacements(), 0};
   if (isLikelyXml(Code))
     return {tooling::Replacements(), 0};
   if (Expanded.Language == FormatStyle::LK_JavaScript && isMpegTS(Code))
     return {tooling::Replacements(), 0};
reformat(const FormatStyle &Style, StringRef Code,
 
   if (Style.Language == FormatStyle::LK_JavaScript &&
       Style.JavaScriptQuotes != FormatStyle::JSQS_Leave)
     Passes.emplace_back([&](const Environment &Env) {
       return JavaScriptRequoter(Env, Expanded).process();
     });
 
   Passes.emplace_back([&](const Environment &Env) {
-    return Formatter(Env, Expanded, Status).process();
+    return Formatter(Env, Expanded, FormattingOptions, Status).process();
   });
 
   auto Env =
       llvm::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn,
                                      NextStartColumn, LastStartColumn);
   llvm::Optional<std::string> CurrentCode = None;
   tooling::Replacements Fixes;
   unsigned Penalty = 0;

 
 tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName,
                                FormattingAttemptStatus *Status) {
   return internal::reformat(Style, Code, Ranges,
                             /*FirstStartColumn=*/0,
                             /*NextStartColumn=*/0,
-                            /*LastStartColumn=*/0, FileName, Status)
+                            /*LastStartColumn=*/0, FileName,
+                            ExtraFormattingOptions::None, Status)
+      .first;
+}
+
+tooling::Replacements reformat(const FormatStyle &Style,
+                               ExtraFormattingOptions FormattingOptions,
+                               StringRef Code, ArrayRef<tooling::Range> Ranges,
+                               StringRef FileName,
+                               FormattingAttemptStatus *Status) {
+  return internal::reformat(Style, Code, Ranges,
+      /*FirstStartColumn=*/0,
+      /*NextStartColumn=*/0,
+      /*LastStartColumn=*/0, FileName, FormattingOptions,
+                            Status)
       .first;
 }
 
 tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
                               ArrayRef<tooling::Range> Ranges,
                               StringRef FileName) {
   // cleanups only apply to C++ (they mostly concern ctor commas etc.)
   if (Style.Language != FormatStyle::LK_Cpp)

clang/lib/Format/FormatInternal.h

 ///     returns 0.
 ///
 /// If ``Status`` is non-null, its value will be populated with the status of
 /// this formatting attempt. See \c FormattingAttemptStatus.
 std::pair<tooling::Replacements, unsigned>
 reformat(const FormatStyle &Style, StringRef Code,
          ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
          unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName,
+         ExtraFormattingOptions FormattingOptions,
          FormattingAttemptStatus *Status);
 
 } // namespace internal
 } // namespace format
 } // namespace clang
 
 #endif

clang/lib/Format/TokenAnalyzer.h

private:
   SmallVector<CharSourceRange, 8> CharRanges;
   unsigned FirstStartColumn;
   unsigned NextStartColumn;
   unsigned LastStartColumn;
 };
 
 class TokenAnalyzer : public UnwrappedLineConsumer {
 public:
-  TokenAnalyzer(const Environment &Env, const FormatStyle &Style);
+  TokenAnalyzer(
+      const Environment &Env, const FormatStyle &Style,
+      ExtraFormattingOptions FormattingOptions = ExtraFormattingOptions::None);
 
   std::pair<tooling::Replacements, unsigned> process();
 
 protected:
   virtual std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) = 0;
 
   void consumeUnwrappedLine(const UnwrappedLine &TheLine) override;
 
   void finishRun() override;
 
   FormatStyle Style;
   // Stores Style, FileID and SourceManager etc.
   const Environment &Env;
   // AffectedRangeMgr stores ranges to be fixed.
   AffectedRangeManager AffectedRangeMgr;
   SmallVector<SmallVector<UnwrappedLine, 16>, 2> UnwrappedLines;
   encoding::Encoding Encoding;
+  ExtraFormattingOptions FormattingOptions;
 };
 
 } // end namespace format
 } // end namespace clang
 
 #endif

clang/lib/Format/TokenAnalyzer.cpp

Environment::Environment(StringRef Code, StringRef FileName,
   SourceLocation StartOfFile = SM.getLocForStartOfFile(ID);
   for (const tooling::Range &Range : Ranges) {
     SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
     SourceLocation End = Start.getLocWithOffset(Range.getLength());
     CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
   }
 }
 
-TokenAnalyzer::TokenAnalyzer(const Environment &Env, const FormatStyle &Style)
+TokenAnalyzer::TokenAnalyzer(const Environment &Env, const FormatStyle &Style,
+                             ExtraFormattingOptions FormattingOptions)
     : Style(Style), Env(Env),
       AffectedRangeMgr(Env.getSourceManager(), Env.getCharRanges()),
       UnwrappedLines(1),
       Encoding(encoding::detectEncoding(
-          Env.getSourceManager().getBufferData(Env.getFileID()))) {
+          Env.getSourceManager().getBufferData(Env.getFileID()))),
+      FormattingOptions(FormattingOptions) {
   LLVM_DEBUG(
       llvm::dbgs() << "File encoding: "
                    << (Encoding == encoding::Encoding_UTF8 ? "UTF8" : "unknown")
                    << "\n");
   LLVM_DEBUG(llvm::dbgs() << "Language: " << getLanguageName(Style.Language)
                           << "\n");
 }
 
 std::pair<tooling::Replacements, unsigned> TokenAnalyzer::process() {
   tooling::Replacements Result;
   FormatTokenLexer Tokens(Env.getSourceManager(), Env.getFileID(),
                           Env.getFirstStartColumn(), Style, Encoding);
 
   UnwrappedLineParser Parser(Style, Tokens.getKeywords(),
-                             Env.getFirstStartColumn(), Tokens.lex(), *this);
+                             Env.getFirstStartColumn(), Tokens.lex(), *this,
+                             FormattingOptions);
   Parser.parse();
   assert(UnwrappedLines.rbegin()->empty());
   unsigned Penalty = 0;
   for (unsigned Run = 0, RunE = UnwrappedLines.size(); Run + 1 != RunE; ++Run) {
     LLVM_DEBUG(llvm::dbgs() << "Run " << Run << "...\n");
     SmallVector<AnnotatedLine *, 16> AnnotatedLines;
 
     TokenAnnotator Annotator(Style, Tokens.getKeywords());

clang/lib/Format/UnwrappedLineFormatter.h

 
 class UnwrappedLineFormatter {
 public:
   UnwrappedLineFormatter(ContinuationIndenter *Indenter,
                          WhitespaceManager *Whitespaces,
                          const FormatStyle &Style,
                          const AdditionalKeywords &Keywords,
                          const SourceManager &SourceMgr,
+                         ExtraFormattingOptions FormattingOptions,
                          FormattingAttemptStatus *Status)
       : Indenter(Indenter), Whitespaces(Whitespaces), Style(Style),
-        Keywords(Keywords), SourceMgr(SourceMgr), Status(Status) {}
+        Keywords(Keywords), SourceMgr(SourceMgr),
+        FormattingOptions(FormattingOptions), Status(Status) {}
 
   /// Format the current block and return the penalty.
   unsigned format(const SmallVectorImpl<AnnotatedLine *> &Lines,
                   bool DryRun = false, int AdditionalIndent = 0,
                   bool FixBadIndentation = false, unsigned FirstStartColumn = 0,
                   unsigned NextStartColumn = 0, unsigned LastStartColumn = 0);
 
 private:
std::map<std::pair<const SmallVectorImpl<AnnotatedLine *> *, unsigned>,
            unsigned>
       PenaltyCache;
 
   ContinuationIndenter *Indenter;
   WhitespaceManager *Whitespaces;
   const FormatStyle &Style;
   const AdditionalKeywords &Keywords;
   const SourceManager &SourceMgr;
+  ExtraFormattingOptions FormattingOptions;
   FormattingAttemptStatus *Status;
 };
 } // end namespace format
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_FORMAT_UNWRAPPEDLINEFORMATTER_H

clang/lib/Format/UnwrappedLineFormatter.cpp

static void printLineState(const LineState &State) {
   }
   llvm::dbgs() << State.NextToken->TokenText << "\n";
 }
 #endif
 
 /// Base class for classes that format one \c AnnotatedLine.
 class LineFormatter {
 public:
-  LineFormatter(ContinuationIndenter *Indenter, WhitespaceManager *Whitespaces,
-                const FormatStyle &Style,
-                UnwrappedLineFormatter *BlockFormatter)
+  LineFormatter(
+      ContinuationIndenter *Indenter, WhitespaceManager *Whitespaces,
+      const FormatStyle &Style, UnwrappedLineFormatter *BlockFormatter,
+      ExtraFormattingOptions FormattingOptions = ExtraFormattingOptions::None)
       : Indenter(Indenter), Whitespaces(Whitespaces), Style(Style),
-        BlockFormatter(BlockFormatter) {}
+        BlockFormatter(BlockFormatter), FormattingOptions(FormattingOptions) {}
   virtual ~LineFormatter() {}
 
   /// Formats an \c AnnotatedLine and returns the penalty.
   ///
   /// If \p DryRun is \c false, directly applies the changes.
   virtual unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
                               unsigned FirstStartColumn, bool DryRun) = 0;
 
bool formatChildren(LineState &State, bool NewLine, bool DryRun,
     const FormatToken *LBrace = State.NextToken->getPreviousNonComment();
     FormatToken &Previous = *State.NextToken->Previous;
     if (!LBrace || LBrace->isNot(tok::l_brace) ||
         LBrace->BlockKind != BK_Block || Previous.Children.size() == 0)
       // The previous token does not open a block. Nothing to do. We don't
       // assert so that we can simply call this function for all tokens.
       return true;
 
-    if (NewLine) {
+    if (NewLine || (Previous.Children[0]->First->MustBreakBefore &&
+                    alwaysKeepLineBreaks(FormattingOptions))) {
       int AdditionalIndent = State.Stack.back().Indent -
                              Previous.Children[0]->Level * Style.IndentWidth;
 
       Penalty +=
           BlockFormatter->format(Previous.Children, DryRun, AdditionalIndent,
                                  /*FixBadIndentation=*/true);
       return true;
     }
protected:
   }
 
   ContinuationIndenter *Indenter;
 
 private:
   WhitespaceManager *Whitespaces;
   const FormatStyle &Style;
   UnwrappedLineFormatter *BlockFormatter;
+  ExtraFormattingOptions FormattingOptions;
 };
 
 /// Formatter that keeps the existing line breaks.
 class NoColumnLimitLineFormatter : public LineFormatter {
 public:
   NoColumnLimitLineFormatter(ContinuationIndenter *Indenter,
                              WhitespaceManager *Whitespaces,
                              const FormatStyle &Style,
-                             UnwrappedLineFormatter *BlockFormatter)
-      : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter) {}
+                             UnwrappedLineFormatter *BlockFormatter,
+                             ExtraFormattingOptions FormattingOptions)
+      : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter,
+                      FormattingOptions) {}
 
   /// Formats the line, simply keeping all of the input's line breaking
   /// decisions.
   unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
                       unsigned FirstStartColumn, bool DryRun) override {
     assert(!DryRun);
     LineState State = Indenter->getInitialState(FirstIndent, FirstStartColumn,
                                                 &Line, /*DryRun=*/false);
public:
 
   /// Puts all tokens into a single line.
   unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
                       unsigned FirstStartColumn, bool DryRun) override {
     unsigned Penalty = 0;
     LineState State =
         Indenter->getInitialState(FirstIndent, FirstStartColumn, &Line, DryRun);
     while (State.NextToken) {
-      formatChildren(State, /*Newline=*/false, DryRun, Penalty);
+      bool Newline = false;
+      formatChildren(State, Newline, DryRun, Penalty);
       Indenter->addTokenToState(
           State, /*Newline=*/State.NextToken->MustBreakBefore, DryRun);
     }
     return Penalty;
   }
 };
 
 /// Finds the best way to break lines.
if (ShouldFormat && TheLine.Type != LT_Invalid) {
       unsigned ColumnLimit = getColumnLimit(TheLine.InPPDirective, NextLine);
       bool FitsIntoOneLine =
           TheLine.Last->TotalLength + Indent <= ColumnLimit ||
           (TheLine.Type == LT_ImportStatement &&
            (Style.Language != FormatStyle::LK_JavaScript ||
             !Style.JavaScriptWrapImports)) ||
           (Style.isCSharp() &&
            TheLine.InPPDirective); // don't split #regions in C#
-      if (Style.ColumnLimit == 0)
-        NoColumnLimitLineFormatter(Indenter, Whitespaces, Style, this)
+      if (Style.ColumnLimit == 0 || alwaysKeepLineBreaks(FormattingOptions))
+        NoColumnLimitLineFormatter(Indenter, Whitespaces, Style, this,
+                                   FormattingOptions)
             .formatLine(TheLine, NextStartColumn + Indent,
                         FirstLine ? FirstStartColumn : 0, DryRun);
       else if (FitsIntoOneLine)
         Penalty += NoLineBreakFormatter(Indenter, Whitespaces, Style, this)
                        .formatLine(TheLine, NextStartColumn + Indent,
                                    FirstLine ? FirstStartColumn : 0, DryRun);
       else
         Penalty += OptimizingLineFormatter(Indenter, Whitespaces, Style, this)

clang/lib/Format/UnwrappedLineParser.h

 
 class FormatTokenSource;
 
 class UnwrappedLineParser {
 public:
   UnwrappedLineParser(const FormatStyle &Style,
                       const AdditionalKeywords &Keywords,
                       unsigned FirstStartColumn, ArrayRef<FormatToken *> Tokens,
-                      UnwrappedLineConsumer &Callback);
+                      UnwrappedLineConsumer &Callback,
+                      ExtraFormattingOptions FormattingOptions);
 
   void parse();
 
 private:
   void reset();
   void parseFile();
   void parseLevel(bool HasOpeningBrace);
   void parseBlock(bool MustBeDeclaration, bool AddLevel = true,
private:
   // IncludeGuardState == IG_IfNdefed.
   FormatToken *IncludeGuardToken;
 
   // Contains the first start column where the source begins. This is zero for
   // normal source code and may be nonzero when formatting a code fragment that
   // does not start at the beginning of the file.
   unsigned FirstStartColumn;
 
+  ExtraFormattingOptions FormattingOptions;
+
   friend class ScopedLineState;
   friend class CompoundStatementIndenter;
 };
 
 struct UnwrappedLineNode {
   UnwrappedLineNode() : Tok(nullptr) {}
   UnwrappedLineNode(FormatToken *Tok) : Tok(Tok) {}
 

clang/lib/Format/UnwrappedLineParser.cpp

 
 private:
   ArrayRef<FormatToken *> Tokens;
   int Position;
 };
 
 } // end anonymous namespace
 
-UnwrappedLineParser::UnwrappedLineParser(const FormatStyle &Style,
-                                         const AdditionalKeywords &Keywords,
-                                         unsigned FirstStartColumn,
-                                         ArrayRef<FormatToken *> Tokens,
-                                         UnwrappedLineConsumer &Callback)
+UnwrappedLineParser::UnwrappedLineParser(
+    const FormatStyle &Style, const AdditionalKeywords &Keywords,
+    unsigned FirstStartColumn, ArrayRef<FormatToken *> Tokens,
+    UnwrappedLineConsumer &Callback, ExtraFormattingOptions FormattingOptions)
     : Line(new UnwrappedLine), MustBreakBeforeNextToken(false),
       CurrentLines(&Lines), Style(Style), Keywords(Keywords),
       CommentPragmasRegex(Style.CommentPragmas), Tokens(nullptr),
       Callback(Callback), AllTokens(Tokens), PPBranchLevel(-1),
       IncludeGuard(Style.IndentPPDirectives == FormatStyle::PPDIS_None
                        ? IG_Rejected
                        : IG_Inited),
-      IncludeGuardToken(nullptr), FirstStartColumn(FirstStartColumn) {}
+      IncludeGuardToken(nullptr), FirstStartColumn(FirstStartColumn),
+      FormattingOptions(FormattingOptions) {}
 
 void UnwrappedLineParser::reset() {
   PPBranchLevel = -1;
   IncludeGuard = Style.IndentPPDirectives == FormatStyle::PPDIS_None
                      ? IG_Rejected
                      : IG_Inited;
   IncludeGuardToken = nullptr;
   Line.reset(new UnwrappedLine);
void UnwrappedLineParser::nextToken(int LevelDifference) {
   flushComments(isOnNewLine(*FormatTok));
   pushToken(FormatTok);
   FormatToken *Previous = FormatTok;
   if (Style.Language != FormatStyle::LK_JavaScript)
     readToken(LevelDifference);
   else
     readTokenWithJavaScriptASI();
   FormatTok->Previous = Previous;
+
+
+  if (FormatTok->NewlinesBefore && alwaysKeepLineBreaks(FormattingOptions))
+    FormatTok->MustBreakBefore = true;
 }
 
 void UnwrappedLineParser::distributeComments(
     const SmallVectorImpl<FormatToken *> &Comments,
     const FormatToken *NextTok) {
   // Whether or not a line comment token continues a line is controlled by
   // the method continuesLineCommentSection, with the following caveat:
   //

clang/tools/clang-format/ClangFormat.cpp

Lengths("length",
                      "Multiple ranges can be formatted by specifying\n"
                      "several -offset and -length pairs.\n"
                      "When only a single -offset is specified without\n"
                      "-length, clang-format will format up to the end\n"
                      "of the file.\n"
                      "Can only be used with one input file."),
             cl::cat(ClangFormatCategory));
 static cl::list<std::string>
-LineRanges("lines", cl::desc("<start line>:<end line> - format a range of\n"
-                             "lines (both 1-based).\n"
-                             "Multiple ranges can be formatted by specifying\n"
-                             "several -lines arguments.\n"
-                             "Can't be used with -offset and -length.\n"
-                             "Can only be used with one input file."),
+    LineRanges("lines",
+               cl::desc("<start line>:<end line> - format a range of\n"
                cl::cat(ClangFormatCategory));
 static cl::opt<std::string>
     Style("style", cl::desc(clang::format::StyleOptionHelpDescription),
           cl::init(clang::format::DefaultFormatStyle),
           cl::cat(ClangFormatCategory));
 static cl::opt<std::string>
     FallbackStyle("fallback-style",
                   cl::desc("The name of the predefined style used as a\n"
                            "fallback in case clang-format is invoked with\n"
                            "-style=file, but can not find the .clang-format\n"
                            "file to use.\n"
                            "Use -fallback-style=none to skip formatting."),
                   cl::init(clang::format::DefaultFallbackStyle),
                   cl::cat(ClangFormatCategory));
 
-static cl::opt<std::string>
-AssumeFileName("assume-filename",
-               cl::desc("When reading from stdin, clang-format assumes this\n"
-                        "filename to look for a style config file (with\n"
-                        "-style=file) and to determine the language."),
-               cl::init("<stdin>"), cl::cat(ClangFormatCategory));
+static cl::opt<std::string> AssumeFileName(
+    "assume-filename",
 
 static cl::opt<bool> Inplace("i",
                              cl::desc("Inplace edit <file>s, if specified."),
                              cl::cat(ClangFormatCategory));
 
 static cl::opt<bool> OutputXML("output-replacements-xml",
                                cl::desc("Output replacements as XML."),
                                cl::cat(ClangFormatCategory));
static cl::opt<bool> SortIncludes(
     cl::desc("If set, overrides the include sorting behavior determined by the "
              "SortIncludes style flag"),
     cl::cat(ClangFormatCategory));
 
 static cl::opt<bool>
     Verbose("verbose", cl::desc("If set, shows the list of processed files"),
             cl::cat(ClangFormatCategory));
 
+static cl::opt<bool>
+    KeepLineBreaks("keep-line-breaks",
+                   cl::desc("If set, keeps all existing line breaks"),
+                   cl::cat(ClangFormatCategory));
+
 static cl::list<std::string> FileNames(cl::Positional, cl::desc("[<file> ...]"),
                                        cl::cat(ClangFormatCategory));
 
 namespace clang {
 namespace format {
 
 static FileID createInMemoryFile(StringRef FileName, MemoryBuffer *Source,
                                  SourceManager &Sources, FileManager &Files,
outs() << "<replacement "
            << "offset='" << R.getOffset() << "' "
            << "length='" << R.getLength() << "'>";
     outputReplacementXML(R.getReplacementText());
     outs() << "</replacement>\n";
   }
 }
 
 // Returns true on error.
-static bool format(StringRef FileName) {
+static bool
+format(StringRef FileName,
+       ExtraFormattingOptions ExtraOptions = ExtraFormattingOptions::None) {
   if (!OutputXML && Inplace && FileName == "-") {
     errs() << "error: cannot use -i when reading from stdin.\n";
     return false;
   }
   // On Windows, overwriting a file with an open file mapping doesn't work,
   // so read the whole file into memory when formatting in-place.
   ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
-      !OutputXML && Inplace ? MemoryBuffer::getFileAsStream(FileName) :
-                              MemoryBuffer::getFileOrSTDIN(FileName);
+      !OutputXML && Inplace ? MemoryBuffer::getFileAsStream(FileName)
+                            : MemoryBuffer::getFileOrSTDIN(FileName);
   if (std::error_code EC = CodeOrErr.getError()) {
     errs() << EC.message() << "\n";
     return true;
   }
   std::unique_ptr<llvm::MemoryBuffer> Code = std::move(CodeOrErr.get());
   if (Code->getBufferSize() == 0)
     return false; // Empty files are formatted correctly.
 
   // Check to see if the buffer has a UTF Byte Order Mark (BOM).
   // We only support UTF-8 with and without a BOM right now.  See
   // https://en.wikipedia.org/wiki/Byte_order_mark#Byte_order_marks_by_encoding
   // for more information.
   StringRef BufStr = Code->getBuffer();
-  const char *InvalidBOM = llvm::StringSwitch<const char *>(BufStr)
+  const char *InvalidBOM =
+      llvm::StringSwitch<const char *>(BufStr)
           .StartsWith(llvm::StringLiteral::withInnerNUL("\x00\x00\xFE\xFF"),
-                                                  "UTF-32 (BE)")
           .StartsWith(llvm::StringLiteral::withInnerNUL("\xFF\xFE\x00\x00"),
-                                                  "UTF-32 (LE)")
           .StartsWith("\xFE\xFF", "UTF-16 (BE)")
           .StartsWith("\xFF\xFE", "UTF-16 (LE)")
           .StartsWith("\x2B\x2F\x76", "UTF-7")
           .StartsWith("\xF7\x64\x4C", "UTF-1")
           .StartsWith("\xDD\x73\x66\x73", "UTF-EBCDIC")
           .StartsWith("\x0E\xFE\xFF", "SCSU")
           .StartsWith("\xFB\xEE\x28", "BOCU-1")
           .StartsWith("\x84\x31\x95\x33", "GB-18030")
           .Default(nullptr);
 
   if (InvalidBOM) {
     errs() << "error: encoding with unsupported byte order mark \""
            << InvalidBOM << "\" detected";
     if (FileName != "-")
       errs() << " in file '" << FileName << "'";
     errs() << ".\n";
     return true;
format(StringRef FileName,
   auto ChangedCode = tooling::applyAllReplacements(Code->getBuffer(), Replaces);
   if (!ChangedCode) {
     llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
     return true;
   }
   // Get new affected ranges after sorting `#includes`.
   Ranges = tooling::calculateRangesAfterReplacements(Replaces, Ranges);
   FormattingAttemptStatus Status;
-  Replacements FormatChanges = reformat(*FormatStyle, *ChangedCode, Ranges,
-                                        AssumedFileName, &Status);
+  Replacements FormatChanges =
+      reformat(*FormatStyle, ExtraOptions, *ChangedCode, Ranges,
   Replaces = Replaces.merge(FormatChanges);
   if (OutputXML) {
     outs() << "<?xml version='1.0'?>\n<replacements "
               "xml:space='preserve' incomplete_format='"
            << (Status.FormatComplete ? "false" : "true") << "'";
     if (!Status.FormatComplete)
       outs() << " line='" << Status.Line << "'";
     outs() << ">\n";
if (Inplace) {
         outs() << " }\n";
       }
       Rewrite.getEditBuffer(ID).write(outs());
     }
   }
   return false;
 }
 
-}  // namespace format
-}  // namespace clang
+} // namespace format
+} // namespace clang
 
 static void PrintVersion(raw_ostream &OS) {
   OS << clang::getClangToolFullVersion("clang-format") << '\n';
 }
 
 int main(int argc, const char **argv) {
   llvm::InitLLVM X(argc, argv);
 
if (!FormatStyle) {
       llvm::errs() << llvm::toString(FormatStyle.takeError()) << "\n";
       return 1;
     }
     std::string Config = clang::format::configurationAsText(*FormatStyle);
     outs() << Config << "\n";
     return 0;
   }
 
+  clang::format::ExtraFormattingOptions ExtraOptions =
+      clang::format::ExtraFormattingOptions::None;
+  if (KeepLineBreaks.getNumOccurrences() != 0) {
+    ExtraOptions =
+        ExtraOptions |
+        clang::format::ExtraFormattingOptions::KeepLineBreaksForNonEmptyLines;
+  }
+
   bool Error = false;
   if (FileNames.empty()) {
     Error = clang::format::format("-");
     return Error ? 1 : 0;
   }
-  if (FileNames.size() != 1 && (!Offsets.empty() || !Lengths.empty() || !LineRanges.empty())) {
+  if (FileNames.size() != 1 &&
+      (!Offsets.empty() || !Lengths.empty() || !LineRanges.empty())) {
     errs() << "error: -offset, -length and -lines can only be used for "
               "single file.\n";
     return 1;
   }
   for (const auto &FileName : FileNames) {
     if (Verbose)
       errs() << "Formatting " << FileName << "\n";
-    Error |= clang::format::format(FileName);
+    Error |= clang::format::format(FileName, ExtraOptions);
   }
   return Error ? 1 : 0;
 }

clang/unittests/Format/FormatTest.cpp

 class FormatTest : public ::testing::Test {
 protected:
   enum StatusCheck {
     SC_ExpectComplete,
     SC_ExpectIncomplete,
     SC_DoNotCheck
   };
 
-  std::string format(llvm::StringRef Code,
-                     const FormatStyle &Style = getLLVMStyle(),
-                     StatusCheck CheckComplete = SC_ExpectComplete) {
+  std::string
+  format(llvm::StringRef Code, const FormatStyle &Style = getLLVMStyle(),
+         StatusCheck CheckComplete = SC_ExpectComplete,
+         ExtraFormattingOptions ExtraOptions = ExtraFormattingOptions::None) {
     LLVM_DEBUG(llvm::errs() << "---\n");
     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
     FormattingAttemptStatus Status;
     tooling::Replacements Replaces =
-        reformat(Style, Code, Ranges, "<stdin>", &Status);
+        reformat(Style, ExtraOptions, Code, Ranges, "<stdin>", &Status);
     if (CheckComplete != SC_DoNotCheck) {
       bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete;
       EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
           << Code << "\n\n";
     }
     ReplacementCount = Replaces.size();
     auto Result = applyAllReplacements(Code, Replaces);
     EXPECT_TRUE(static_cast<bool>(Result));
EXPECT_EQ("class Foo\n"
                    "  {\n"
                    "  }\n"
                    "\n"
                    "  void funk() {}\n"
                    "};",
                    Style));
 }
 
+TEST_F(FormatTest, KeepsLineBreaks) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ("if (a\n"
+            "    && b) {\n"
+            "}",
+            format("if (a\n"
+                   "    && b) {\n"
+                   "}",
+                   Style, SC_ExpectComplete,
+                   ExtraFormattingOptions::KeepLineBreaksForNonEmptyLines));
+
+  EXPECT_EQ("[]() {\n"
+            "  foo(); }",
+            format("[]() {\n"
+                   "foo(); }",
+                   Style, SC_ExpectComplete,
+                   ExtraFormattingOptions::KeepLineBreaksForNonEmptyLines));
+}
+
 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
   verifyFormat("x = (a) and (b);");
   verifyFormat("x = (a) or (b);");
   verifyFormat("x = (a) bitand (b);");
   verifyFormat("x = (a) bitor (b);");
   verifyFormat("x = (a) not_eq (b);");
   verifyFormat("x = (a) and_eq (b);");
   verifyFormat("x = (a) or_eq (b);");