[clang-format] Add an experimental option to remove optional control statement braces in LLVM C++ code

[owenpan]

Summary

See the LLVM style examples. This option can be expanded/configured to support other styles.

[curdeius]

Could you have a look at preceding reviews and see if there wasn't a similar patch before?
I think that this option is a bit too limited.
Only removing braces doesn't seem enough.
Also, one should probably be able to decide when to add/remove them by e.g. setting the number of lines in what's considered short blocks.

clang/docs/ClangFormatStyleOptions.rst

3398

I don't think it's a good idea to make this option dependent on a particular style. Even if it works for LLVM style only for the moment.

3419

I'm not sure if the braces on the right should be removed in the for loop.
There should probably be an option to set the minimum number of lines/statements inside a control statement to control adding/removing braces.

[MyDeveloperDay]

See D95168: [clang-format] Add Insert/Remove Braces option

[HazardyKnusperkeks]

In D116316#3211269, @curdeius wrote:

Could you have a look at preceding reviews and see if there wasn't a similar patch before?
I think that this option is a bit too limited.
Only removing braces doesn't seem enough.
Also, one should probably be able to decide when to add/remove them by e.g. setting the number of lines in what's considered short blocks.

There is D95168.

clang/lib/Format/UnwrappedLineParser.cpp

484

This is very confusing a variable with the same name as the function.

2184

constexpr or configurable?

2389

I think it is worth to create a RAII type for that.

2984

I would like it better if you insert both arguments.
I don't really like default arguments.

clang/lib/Format/UnwrappedLineParser.h

198

I find it nicely if the order of functions in the cpp is the same as in the hpp.

199

[owenpan]

clang/docs/ClangFormatStyleOptions.rst

3419

I'm not sure if the braces on the right should be removed in the for loop.

This is the LLVM style. See also line 23086 in FormatTest.cpp below.

There should probably be an option to set the minimum number of lines/statements inside a control statement to control adding/removing braces.

If you have more than one statement inside a control statement block, the braces must stay.

[owenpan]

Addresses review comments.

[owenpan]

clang/lib/Format/UnwrappedLineParser.cpp

2184

It will be configurable when we expand removing braces to other styles.

2389

Can you explain why an RAII type would be beneficial here?

2984

I'm the opposite, and parseBlock()is a good example. However, I restored the previously non-default argument.

clang/lib/Format/UnwrappedLineParser.h

198

Me too although some of the functions (e.g. parseCSharpGenericTypeConstraint and parseCSharpAttribute) were already out of order.

[owenpan]

In D116316#3211269, @curdeius wrote:

Could you have a look at preceding reviews and see if there wasn't a similar patch before?

I conversed with @MyDeveloperDay in D95168. In fact, that was one of the main reasons that I put in extra effort to get this patch done.

I think that this option is a bit too limited.
Only removing braces doesn't seem enough.

I wanted to implement as many features as possible using the limited parser of clang-format, and the LLVM style would be a very high bar to clear. Only focusing on LLVM now will actually make this option less limited if and when we are ready to support other styles. It would be mostly configuring/packaging what have already worked for LLVM.

Also, one should probably be able to decide when to add/remove them by e.g. setting the number of lines in what's considered short blocks.

Agreed, but if clang-format can't do insertion well independent of removal and vice versa, we probably will never get there.

So far, this patch has successfully applied to clang/lib/Format, i.e., it builds successfully and passes FormatTests.

[MyDeveloperDay]

clang/docs/ClangFormatStyleOptions.rst

3398

Can we agree on one set of options that can be used for both insertion and removal even if this patch only does removal

clang/unittests/Format/FormatTest.cpp

23224

any reason these can't be verifyFormats?

[HazardyKnusperkeks]

clang/lib/Format/UnwrappedLineParser.cpp

2389

You have a lot of push/pop pairs. There is the risk someone (in the future) may misuse it.

[owenpan]

Fixed a bug and added a test case.

[HazardyKnusperkeks]

clang/lib/Format/UnwrappedLineParser.cpp

2338

Why null that?

[owenpan]

clang/docs/ClangFormatStyleOptions.rst

3398

I don't think it's a good idea to make this option dependent on a particular style. Even if it works for LLVM style only for the moment.

As @MyDeveloperDay said before, eliding braces was (by far?) the most frequent review comments, and the community would appreciate something like this. So it's likely that this option will get used and experimented, and we will get bug reports and other feedback to improve the functionalities. Once we think it's ready, we can easily configure/package the functionalities for other styles.

3398

Can we agree on one set of options that can be used for both insertion and removal even if this patch only does removal

One idea is to run insertion for all missing braces and then this option to remove the optional ones for LLVM, i.e., an AutomaticBraces if you will.

clang/lib/Format/UnwrappedLineParser.cpp

2389

I see. I will think about it.

clang/unittests/Format/FormatTest.cpp

23224

Did you mean to add the expected part as a separate case? I don't think it would add any value if there are no braces to remove in the first place?

[owenpan]

clang/lib/Format/UnwrappedLineParser.cpp

2338

MatchingParen is used to flag braces that may be optional. If it turns out that they should not be removed, we must reset it. Otherwise, the test case on line 23314 in FormatTest.cpp below would fail.

[owenpan]

clang/unittests/Format/FormatTest.cpp

23224

Did you mean to add the expected part as a separate case? I don't think it would add any value if there are no braces to remove in the first place?

Nvm. I think you wanted something like verifyFormat(PostformatCode, PreformatCode, Style)? Yes, I could do that, but I would have to relax the restriction to calling BracesRemover() in Format.cpp, i.e. checking isCpp() instead.

[HazardyKnusperkeks]

clang/lib/Format/UnwrappedLineParser.cpp

2338

Is MatchingParen for (if) braces null before this patch? Because I would expect that always to be set, if there is a matching brace and maybe base patches on that assumption.

[owenpan]

clang/lib/Format/UnwrappedLineParser.cpp

2338

Yes, it's not set until it's in the token annotator. That's why I added the assertion in the annotator.

[owenpan]

• Fixed a bug found by applying the patch on the entire clang source tree.
• Added an exception: the braces are not removed if the right one is followed by a comment on the same line.
• Updated an existing test case and added a new one.

[owenpan]

Fixing a couple of major bugs found by running check-clang plus minor bug fixes and cleanup:

• In parseLevel(), HasOpeningBrace and case tok::r_brace: don't necessarily mean the tokens are { and }, respectively.
• A pair of braces may be subject to removal even if the } is followed by a non-trailing comment.
• The newline before a wrapped { should be deleted when removing the braces.
• precededByCommentOrPPDirective() should be a const member function.
• The assertion that a { of a control statement block is not parsed more than once is false.

Now this patch not only successfully builds clang but also passes check-clang (by not failing more tests than the current clang-format).

[MyDeveloperDay]

Owen I think we should push ahead with this rather than D95168: [clang-format] Add Insert/Remove Braces option as I've looked at what you've done here I'm reminded that the removal and insertion are likely mutually exclusive operations.

There is no doubt that insertion is desired (so I'd like to see us do that afterwards) but I now think that could be in a completely separate pass as you originally suggested.

LGTM

[owenpan]

In D116316#3224591, @MyDeveloperDay wrote:

Owen I think we should push ahead with this rather than D95168: [clang-format] Add Insert/Remove Braces option as I've looked at what you've done here I'm reminded that the removal and insertion are likely mutually exclusive operations.

There is no doubt that insertion is desired (so I'd like to see us do that afterwards) but I now think that could be in a completely separate pass as you originally suggested.

LGTM

Thanks! I will wait a couple of days in case other reviewers have some final requests.

[curdeius]

LGTM with some nits.

clang/lib/Format/UnwrappedLineParser.cpp

435–454

Please remove unused code.

485

Please remove unused code.

clang/unittests/Format/FormatTest.cpp

23224

👍 you should be able to use the 2-argument version of verifyFormat, no?

[owenpan]

clang/lib/Format/UnwrappedLineParser.cpp

435–454

Will do pending D116318.

485

Will do.

clang/unittests/Format/FormatTest.cpp

23224

Will replace all EXPECT_EQs with verifyFormats. Question: when is the former preferred to the latter? It seems EXPECT_EQ is frequently used in FormatTest.cpp.

[owenpan]

• Use verifyFormat instead of EXPECT_EQ.
• Make this option have less impact on the unwrapped line parser by checking Style.RemoveBracesLLVM.
• Remove some unused code.

[owenpan]

• Rebased to main.
• Removed unused code.
• Updated release notes.

[owenpan]

• Braces should not be removed if the single-statement block might wrap or is already wrapped.
• Added test cases.
• Did a final round of cleanup.

[owenpan]

Fixed a bug and added a test case.

[owenpan]

• Removed unnecessary code and cleaned up.
• Tested on clang and check-clang again.

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

3055

This should be two warning blocks.

clang/lib/Format/UnwrappedLineParser.cpp

468

This should be an enum, a bool suggests that the return value is a failure/success indicator.

[owenpan]

clang/include/clang/Format/Format.h

3055

Can you elaborate? I simply copied the format of the existing warning block. The alignment of the \code block below is off by 1 though.

clang/lib/Format/UnwrappedLineParser.cpp

468

Most of the parse...() functions return void with no indication of pass/fail. Some of them return bool, e.g. parseObjCProtocol(), which doesn't indicate pass/fail according to the function header comment. I will add a similar comment.

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

3055

One Warning that the option is going to be renamed.

The other warning regarding the code changes.

clang/lib/Format/UnwrappedLineParser.cpp

468

Yeah I'm out here.

[owenpan]

• Rebased to main.
• Addressed review comments.

[owenpan]

• Fixed a bug that missed braces in nested blocks.
• Added a test case.

[owenpan]

@MyDeveloperDay @curdeius I will land this patch if you have no more comments. :)

[curdeius]

LGTM.

clang/docs/ClangFormatStyleOptions.rst

3398

Have you agreed upon this?

[owenpan]

clang/docs/ClangFormatStyleOptions.rst

3398

Not yet. We probably want to test inserting braces Always on check-clang if it's not already been done.

[MyDeveloperDay]

LGTM go for it.

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: c++
      /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
 
      true:
      // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
      // information
      /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
       * information */
 
+**RemoveBracesLLVM** (``Boolean``) :versionbadge:`clang-format 14`
+  Remove optional braces of control statements (``if``, ``else``, ``for``,
+  and ``while``) in C++ according to the LLVM coding style.
+
+  .. warning:: 
+
+   This option will be renamed and expanded to support other styles!
+   Setting this option to `true` could lead to incorrect code formatting due
+   to clang-format's lack of complete semantic information. As such, extra
+   care should be taken to review code changes made by this option.
+
+  .. code-block:: c++
+
+   false:                                      true:
+
+   if (isa<FunctionDecl>(D)) {         vs.     if (isa<FunctionDecl>(D))
+     handleFunctionDecl(D);                      handleFunctionDecl(D);
+   } else if (isa<VarDecl>(D)) {               else if (isa<VarDecl>(D))
+     handleVarDecl(D);                           handleVarDecl(D);
+   }
+
+   if (isa<VarDecl>(D)) {              vs.     if (isa<VarDecl>(D)) {
+     for (auto *A : D.attrs()) {                 for (auto *A : D.attrs())
+       if (shouldProcessAttr(A)) {                 if (shouldProcessAttr(A))
+         handleAttr(A);                              handleAttr(A);
+       }                                       }
+     }
+   }
+
+   if (isa<FunctionDecl>(D)) {         vs.     if (isa<FunctionDecl>(D))
+     for (auto *A : D.attrs()) {                 for (auto *A : D.attrs())
+       handleAttr(A);                              handleAttr(A);
+     }
+   }
+
+   if (auto *D = (T)(D)) {             vs.     if (auto *D = (T)(D)) {
+     if (shouldProcess(D)) {                     if (shouldProcess(D))
+       handleVarDecl(D);                           handleVarDecl(D);
+     } else {                                    else
+       markAsIgnored(D);                           markAsIgnored(D);
+     }                                         }
+   }
+
+   if (a) {                            vs.     if (a)
+     b();                                        b();
+   } else {                                    else if (c)
+     if (c) {                                    d();
+       d();                                    else
+     } else {                                    e();
+       e();
+     }
+   }
+
 **ShortNamespaceLines** (``Unsigned``) :versionbadge:`clang-format 14`
   The maximal number of unwrapped lines that a short namespace spans.
   Defaults to 1.
 
   This determines the maximum length of short namespaces by counting
   unwrapped lines (i.e. containing neither opening nor closing
   namespace brace) and makes "FixNamespaceComments" omit adding
   end comments for those.

clang/include/clang/Format/Format.h

///    NS_TABLE_.*_END$"
   ///    // information
   ///    /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
   ///     * information */
   /// \endcode
   /// \version 4
   bool ReflowComments;
   // clang-format on
 
+  /// Remove optional braces of control statements (``if``, ``else``, ``for``,
+  /// and ``while``) in C++ according to the LLVM coding style.
+  /// \warning
+  ///  This option will be renamed and expanded to support other styles!
+  ///  Setting this option to `true` could lead to incorrect code formatting due
+  ///  to clang-format's lack of complete semantic information. As such, extra
+  ///  care should be taken to review code changes made by this option.
+  /// \endwarning
+  /// \code
+  ///  false:                                      true:
+  ///
+  ///  if (isa<FunctionDecl>(D)) {         vs.     if (isa<FunctionDecl>(D))
+  ///    handleFunctionDecl(D);                      handleFunctionDecl(D);
+  ///  } else if (isa<VarDecl>(D)) {               else if (isa<VarDecl>(D))
+  ///    handleVarDecl(D);                           handleVarDecl(D);
+  ///  }
+  ///
+  ///  if (isa<VarDecl>(D)) {              vs.     if (isa<VarDecl>(D)) {
+  ///    for (auto *A : D.attrs()) {                 for (auto *A : D.attrs())
+  ///      if (shouldProcessAttr(A)) {                 if (shouldProcessAttr(A))
+  ///        handleAttr(A);                              handleAttr(A);
+  ///      }                                       }
+  ///    }
+  ///  }
+  ///
+  ///  if (isa<FunctionDecl>(D)) {         vs.     if (isa<FunctionDecl>(D))
+  ///    for (auto *A : D.attrs()) {                 for (auto *A : D.attrs())
+  ///      handleAttr(A);                              handleAttr(A);
+  ///    }
+  ///  }
+  ///
+  ///  if (auto *D = (T)(D)) {             vs.     if (auto *D = (T)(D)) {
+  ///    if (shouldProcess(D)) {                     if (shouldProcess(D))
+  ///      handleVarDecl(D);                           handleVarDecl(D);
+  ///    } else {                                    else
+  ///      markAsIgnored(D);                           markAsIgnored(D);
+  ///    }                                         }
+  ///  }
+  ///
+  ///  if (a) {                            vs.     if (a)
+  ///    b();                                        b();
+  ///  } else {                                    else if (c)
+  ///    if (c) {                                    d();
+  ///      d();                                    else
+  ///    } else {                                    e();
+  ///      e();
+  ///    }
+  ///  }
+  /// \endcode
+  /// \version 14
+  bool RemoveBracesLLVM;
+
   /// The maximal number of unwrapped lines that a short namespace spans.
   /// Defaults to 1.
   ///
   /// This determines the maximum length of short namespaces by counting
   /// unwrapped lines (i.e. containing neither opening nor closing
   /// namespace brace) and makes "FixNamespaceComments" omit adding
   /// end comments for those.
   /// \code
return AccessModifierOffset == R.AccessModifierOffset &&
            PenaltyReturnTypeOnItsOwnLine == R.PenaltyReturnTypeOnItsOwnLine &&
            PenaltyBreakTemplateDeclaration ==
                R.PenaltyBreakTemplateDeclaration &&
            PointerAlignment == R.PointerAlignment &&
            QualifierAlignment == R.QualifierAlignment &&
            QualifierOrder == R.QualifierOrder &&
            RawStringFormats == R.RawStringFormats &&
            ReferenceAlignment == R.ReferenceAlignment &&
+           RemoveBracesLLVM == R.RemoveBracesLLVM &&
            ShortNamespaceLines == R.ShortNamespaceLines &&
            SortIncludes == R.SortIncludes &&
            SortJavaStaticImport == R.SortJavaStaticImport &&
            SpaceAfterCStyleCast == R.SpaceAfterCStyleCast &&
            SpaceAfterLogicalNot == R.SpaceAfterLogicalNot &&
            SpaceAfterTemplateKeyword == R.SpaceAfterTemplateKeyword &&
            SpaceBeforeAssignmentOperators == R.SpaceBeforeAssignmentOperators &&
            SpaceBeforeCaseColon == R.SpaceBeforeCaseColon &&

clang/lib/Format/Format.cpp

IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
                    Style.PenaltyReturnTypeOnItsOwnLine);
     IO.mapOptional("PenaltyIndentedWhitespace",
                    Style.PenaltyIndentedWhitespace);
     IO.mapOptional("PointerAlignment", Style.PointerAlignment);
     IO.mapOptional("PPIndentWidth", Style.PPIndentWidth);
     IO.mapOptional("RawStringFormats", Style.RawStringFormats);
     IO.mapOptional("ReferenceAlignment", Style.ReferenceAlignment);
     IO.mapOptional("ReflowComments", Style.ReflowComments);
+    IO.mapOptional("RemoveBracesLLVM", Style.RemoveBracesLLVM);
     IO.mapOptional("ShortNamespaceLines", Style.ShortNamespaceLines);
     IO.mapOptional("SortIncludes", Style.SortIncludes);
     IO.mapOptional("SortJavaStaticImport", Style.SortJavaStaticImport);
     IO.mapOptional("SortUsingDeclarations", Style.SortUsingDeclarations);
     IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
     IO.mapOptional("SpaceAfterLogicalNot", Style.SpaceAfterLogicalNot);
     IO.mapOptional("SpaceAfterTemplateKeyword",
                    Style.SpaceAfterTemplateKeyword);
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
   LLVMStyle.ReferenceAlignment = FormatStyle::RAS_Pointer;
   LLVMStyle.ShortNamespaceLines = 1;
   LLVMStyle.SpacesBeforeTrailingComments = 1;
   LLVMStyle.Standard = FormatStyle::LS_Latest;
   LLVMStyle.UseCRLF = false;
   LLVMStyle.UseTab = FormatStyle::UT_Never;
   LLVMStyle.ReflowComments = true;
+  LLVMStyle.RemoveBracesLLVM = false;
   LLVMStyle.SpacesInParentheses = false;
   LLVMStyle.SpacesInSquareBrackets = false;
   LLVMStyle.SpaceInEmptyBlock = false;
   LLVMStyle.SpaceInEmptyParentheses = false;
   LLVMStyle.SpacesInContainerLiterals = true;
   LLVMStyle.SpacesInCStyleCastParentheses = false;
   LLVMStyle.SpacesInLineCommentPrefix = {/*Minimum=*/1, /*Maximum=*/-1u};
   LLVMStyle.SpaceAfterCStyleCast = false;

 
 llvm::Optional<FormatStyle>
 FormatStyle::GetLanguageStyle(FormatStyle::LanguageKind Language) const {
   return StyleSet.Get(Language);
 }
 
 namespace {
 
+class BracesRemover : public TokenAnalyzer {
+public:
+  BracesRemover(const Environment &Env, const FormatStyle &Style)
+      : TokenAnalyzer(Env, Style) {}
+
+  std::pair<tooling::Replacements, unsigned>
+  analyze(TokenAnnotator &Annotator,
+          SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
+          FormatTokenLexer &Tokens) override {
+    AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
+    tooling::Replacements Result;
+    removeBraces(AnnotatedLines, Result);
+    return {Result, 0};
+  }
+
+private:
+  // Remove optional braces.
+  void removeBraces(SmallVectorImpl<AnnotatedLine *> &Lines,
+                    tooling::Replacements &Result) {
+    const auto &SourceMgr = Env.getSourceManager();
+    for (AnnotatedLine *Line : Lines) {
+      if (!Line->Affected)
+        continue;
+      for (FormatToken *Token = Line->First; Token; Token = Token->Next) {
+        if (!Token->Optional)
+          continue;
+        const auto Start = Token == Line->Last
+                               ? Token->WhitespaceRange.getBegin()
+                               : Token->Tok.getLocation();
+        const auto Range =
+            CharSourceRange::getCharRange(Start, Token->Tok.getEndLoc());
+        cantFail(Result.add(tooling::Replacement(SourceMgr, Range, "")));
+      }
+    }
+  }
+};
+
 class JavaScriptRequoter : public TokenAnalyzer {
 public:
   JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
       : TokenAnalyzer(Env, Style) {}
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
Passes.emplace_back([&](const Environment &Env) {
       return QualifierAlignmentFixer(Env, Expanded, Code, Ranges,
                                      FirstStartColumn, NextStartColumn,
                                      LastStartColumn, FileName)
           .process();
     });
   }
 
   if (Style.Language == FormatStyle::LK_Cpp) {
+    if (Style.RemoveBracesLLVM)
+      Passes.emplace_back([&](const Environment &Env) {
+        return BracesRemover(Env, Expanded).process();
+      });
+
     if (Style.FixNamespaceComments)
       Passes.emplace_back([&](const Environment &Env) {
         return NamespaceEndCommentsFixer(Env, Expanded).process();
       });
 
     if (Style.SortUsingDeclarations)
       Passes.emplace_back([&](const Environment &Env) {
         return UsingDeclarationsSorter(Env, Expanded).process();

clang/lib/Format/FormatToken.h

public:
   bool StartsColumn = false;
 
   /// This notes the start of the line of an array initializer.
   bool ArrayInitializerLineStart = false;
 
   /// This starts an array initializer.
   bool IsArrayInitializer = false;
 
+  /// Is optional and can be removed.
+  bool Optional = false;
+
   /// If this token starts a block, this contains all the unwrapped lines
   /// in it.
   SmallVector<AnnotatedLine *, 1> Children;
 
   // Contains all attributes related to how this token takes part
   // in a configured macro expansion.
   llvm::Optional<MacroExpansion> MacroCtx;
 

clang/lib/Format/TokenAnnotator.cpp

if (CurrentToken) {
         Contexts.back().IsExpression = true;
       if (Style.isJavaScript() && Left->Previous &&
           Left->Previous->is(TT_JsTypeColon))
         Contexts.back().IsExpression = false;
 
       unsigned CommaCount = 0;
       while (CurrentToken) {
         if (CurrentToken->is(tok::r_brace)) {
+          assert(Left->Optional == CurrentToken->Optional);
           Left->MatchingParen = CurrentToken;
           CurrentToken->MatchingParen = Left;
           if (Style.AlignArrayOfStructures != FormatStyle::AIAS_None) {
             if (Left->ParentBracket == tok::l_brace &&
                 couldBeInStructArrayInitializer() && CommaCount > 0) {
               Contexts.back().InStructArrayInitializer = true;
             }
           }

clang/lib/Format/UnwrappedLineParser.h

public:
   UnwrappedLineParser(const FormatStyle &Style,
                       const AdditionalKeywords &Keywords,
                       unsigned FirstStartColumn, ArrayRef<FormatToken *> Tokens,
                       UnwrappedLineConsumer &Callback);
 
   void parse();
 
 private:
+  enum class IfStmtKind {
+    NotIf,   // Not an if statement.
+    IfOnly,  // An if statement without the else clause.
+    IfElse,  // An if statement followed by else but not else if.
+    IfElseIf // An if statement followed by else if.
+  };
+
   void reset();
   void parseFile();
-  void parseLevel(bool HasOpeningBrace);
-  void parseBlock(bool MustBeDeclaration = false, unsigned AddLevels = 1u,
+  bool precededByCommentOrPPDirective() const;
+  bool parseLevel(bool HasOpeningBrace, IfStmtKind *IfKind = nullptr);
+  IfStmtKind parseBlock(bool MustBeDeclaration = false, unsigned AddLevels = 1u,
                         bool MunchSemi = true,
                         bool UnindentWhitesmithsBraces = false);
   void parseChildBlock();
   void parsePPDirective();
   void parsePPDefine();
   void parsePPIf(bool IfDef);
   void parsePPElIf();
   void parsePPElse();
   void parsePPEndIf();
   void parsePPUnknown();
   void readTokenWithJavaScriptASI();
-  void parseStructuralElement(bool IsTopLevel = false);
+  void parseStructuralElement(IfStmtKind *IfKind = nullptr,
+                              bool IsTopLevel = false);
   bool tryToParseBracedList();
   bool parseBracedList(bool ContinueOnSemicolons = false, bool IsEnum = false,
                        tok::TokenKind ClosingBraceKind = tok::r_brace);
   void parseParens();
   void parseSquare(bool LambdaIntroducer = false);
-  void parseIfThenElse();
+  void keepAncestorBraces();
+  FormatToken *parseIfThenElse(IfStmtKind *IfKind, bool KeepBraces = false);
   void parseTryCatch();
   void parseForOrWhileLoop();
   void parseDoWhile();
   void parseLabel(bool LeftAlignLabel = false);
   void parseCaseLabel();
   void parseSwitch();
   void parseNamespace();
   void parseModuleImport();
private:
   // this branch either cannot be taken (for example '#if false'), or should
   // not be taken in this round.
   void conditionalCompilationCondition(bool Unreachable);
   void conditionalCompilationStart(bool Unreachable);
   void conditionalCompilationAlternative();
   void conditionalCompilationEnd();
 
   bool isOnNewLine(const FormatToken &FormatTok);
 
   // Compute hash of the current preprocessor branch.
   // This is used to identify the different branches, and thus track if block
   // open and close in the same branch.
   size_t computePPHash() const;
 
   // FIXME: We are constantly running into bugs where Line.Level is incorrectly
   // subtracted from beyond 0. Introduce a method to subtract from Line.Level
   // and use that everywhere in the Parser.
   std::unique_ptr<UnwrappedLine> Line;
private:
   FormatTokenSource *Tokens;
   UnwrappedLineConsumer &Callback;
 
   // FIXME: This is a temporary measure until we have reworked the ownership
   // of the format tokens. The goal is to have the actual tokens created and
   // owned outside of and handed into the UnwrappedLineParser.
   ArrayRef<FormatToken *> AllTokens;
 
+  // Keeps a stack of the states of nested control statements (true if the
+  // statement contains more than some predefined number of nested statements).
+  SmallVector<bool, 8> NestedTooDeep;
+
   // Represents preprocessor branch type, so we can find matching
   // #if/#else/#endif directives.
   enum PPBranchKind {
     PP_Conditional, // Any #if, #ifdef, #ifndef, #elif, block outside #if 0
     PP_Unreachable  // #if 0 or a conditional preprocessor block inside #if 0
   };
 
   struct PPBranch {

clang/lib/Format/UnwrappedLineParser.cpp

void UnwrappedLineParser::reset() {
   IncludeGuardToken = nullptr;
   Line.reset(new UnwrappedLine);
   CommentsBeforeNextToken.clear();
   FormatTok = nullptr;
   MustBreakBeforeNextToken = false;
   PreprocessorDirectives.clear();
   CurrentLines = &Lines;
   DeclarationScopeStack.clear();
+  NestedTooDeep.clear();
   PPStack.clear();
   Line->FirstStartColumn = FirstStartColumn;
 }
 
 void UnwrappedLineParser::parse() {
   IndexedTokenSource TokenSource(AllTokens);
   Line->FirstStartColumn = FirstStartColumn;
   do {
case tok::l_square:
       break;
     default:
       nextToken();
       break;
     }
   } while (!eof());
 }
 
-void UnwrappedLineParser::parseLevel(bool HasOpeningBrace) {
+bool UnwrappedLineParser::precededByCommentOrPPDirective() const {
+  const size_t size = Lines.size();
+  if (size > 0 && Lines[size - 1].InPPDirective)
+    return true;
+#if 1
+  const unsigned Position = Tokens->getPosition();
+  if (Position == 0)
+    return false;
+  const FormatToken *Previous = AllTokens[Position - 1];
+  assert(Previous);
+  return Previous->is(tok::comment) &&
+#else // Use the #else part after D116318 lands.
+  const FormatToken *Previous = Tokens->getPreviousToken();
+  return Previous && Previous->is(tok::comment) &&
+#endif
+         (Previous->IsMultiline || Previous->NewlinesBefore > 0);
+}
+
+bool UnwrappedLineParser::parseLevel(bool HasOpeningBrace, IfStmtKind *IfKind) {
+  // const bool StartsWithBrace = FormatTok->is(tok::l_brace);
+  const bool IsPrecededByCommentOrPPDirective =
+      precededByCommentOrPPDirective();
+  unsigned StatementCount = 0;
   bool SwitchLabelEncountered = false;
   do {
     tok::TokenKind kind = FormatTok->Tok.getKind();
     if (FormatTok->getType() == TT_MacroBlockBegin) {
       kind = tok::l_brace;
     } else if (FormatTok->getType() == TT_MacroBlockEnd) {
       kind = tok::r_brace;
     }
 
     switch (kind) {
     case tok::comment:
       nextToken();
       addUnwrappedLine();
       break;
     case tok::l_brace:
       // FIXME: Add parameter whether this can happen - if this happens, we must
       // be in a non-declaration context.
       if (!FormatTok->is(TT_MacroBlockBegin) && tryToParseBracedList())
         continue;
       parseBlock();
+      ++StatementCount;
+      assert(StatementCount > 0 && "StatementCount overflow!");
       addUnwrappedLine();
       break;
     case tok::r_brace:
-      if (HasOpeningBrace)
-        return;
+      if (HasOpeningBrace) {
+        if (FormatTok->isNot(tok::r_brace) || StatementCount != 1 ||
+            IsPrecededByCommentOrPPDirective || // StartsWithBrace ||
+            precededByCommentOrPPDirective()) {
+          return false;
+        }
+        const FormatToken *Next = Tokens->peekNextToken();
+        return Next->NewlinesBefore > 0 || Next->isNot(tok::comment);
+      }
       nextToken();
       addUnwrappedLine();
       break;
     case tok::kw_default: {
       unsigned StoredPosition = Tokens->getPosition();
       FormatToken *Next;
       do {
         Next = Tokens->getNextToken();
do {
     case tok::l_square:
       if (Style.isCSharp()) {
         nextToken();
         parseCSharpAttribute();
         break;
       }
       LLVM_FALLTHROUGH;
     default:
-      parseStructuralElement(!HasOpeningBrace);
+      parseStructuralElement(IfKind, !HasOpeningBrace);
+      ++StatementCount;
+      assert(StatementCount > 0 && "StatementCount overflow!");
       break;
     }
   } while (!eof());
+  return false;
 }
 
 void UnwrappedLineParser::calculateBraceTypes(bool ExpectClassBody) {
   // We'll parse forward through the tokens until we hit
   // a closing brace or eof - note that getNextToken() will
   // parse macros, so this will magically work inside macro
   // definitions, too.
   unsigned StoredPosition = Tokens->getPosition();
size_t UnwrappedLineParser::computePPHash() const {
   size_t h = 0;
   for (const auto &i : PPStack) {
     hash_combine(h, size_t(i.Kind));
     hash_combine(h, i.Line);
   }
   return h;
 }
 
-void UnwrappedLineParser::parseBlock(bool MustBeDeclaration, unsigned AddLevels,
-                                     bool MunchSemi,
-                                     bool UnindentWhitesmithsBraces) {
+UnwrappedLineParser::IfStmtKind
+UnwrappedLineParser::parseBlock(bool MustBeDeclaration, unsigned AddLevels,
   assert(FormatTok->isOneOf(tok::l_brace, TT_MacroBlockBegin) &&
          "'{' or macro block token expected");
+  FormatToken *Tok = FormatTok;
   const bool MacroBlock = FormatTok->is(TT_MacroBlockBegin);
   FormatTok->setBlockKind(BK_Block);
 
   // For Whitesmiths mode, jump to the next level prior to skipping over the
   // braces.
   if (AddLevels > 0 && Style.BreakBeforeBraces == FormatStyle::BS_Whitesmiths)
     ++Line->Level;
 
UnwrappedLineParser::parseBlock(bool MustBeDeclaration, unsigned AddLevels,
   // settings. This allows the format to back up one level in those cases.
   if (UnindentWhitesmithsBraces)
     --Line->Level;
 
   ScopedDeclarationState DeclarationState(*Line, DeclarationScopeStack,
                                           MustBeDeclaration);
   if (AddLevels > 0u && Style.BreakBeforeBraces != FormatStyle::BS_Whitesmiths)
     Line->Level += AddLevels;
-  parseLevel(/*HasOpeningBrace=*/true);
+
+  IfStmtKind IfKind = IfStmtKind::NotIf;
+  const bool SimpleBlock = parseLevel(/*HasOpeningBrace=*/true, &IfKind);
 
   if (eof())
-    return;
+    return IfKind;
 
   if (MacroBlock ? !FormatTok->is(TT_MacroBlockEnd)
                  : !FormatTok->is(tok::r_brace)) {
     Line->Level = InitialLevel;
     FormatTok->setBlockKind(BK_Block);
-    return;
+    return IfKind;
+  }
+
+  if (SimpleBlock && Tok->is(tok::l_brace)) {
+    assert(FormatTok->is(tok::r_brace));
+    const FormatToken *Previous = Tokens->getPreviousToken();
+    assert(Previous);
+    if (Previous->isNot(tok::r_brace) || Previous->Optional) {
+      Tok->MatchingParen = FormatTok;
+      FormatTok->MatchingParen = Tok;
+    }
   }
 
   size_t PPEndHash = computePPHash();
 
   // Munch the closing brace.
   nextToken(/*LevelDifference=*/-AddLevels);
 
   if (MacroBlock && FormatTok->is(tok::l_paren))
UnwrappedLineParser::parseBlock(bool MustBeDeclaration, unsigned AddLevels,
   if (PPStartHash == PPEndHash) {
     Line->MatchingOpeningBlockLineIndex = OpeningLineIndex;
     if (OpeningLineIndex != UnwrappedLine::kInvalidIndex) {
       // Update the opening line to add the forward reference as well
       (*CurrentLines)[OpeningLineIndex].MatchingClosingBlockLineIndex =
           CurrentLines->size() - 1;
     }
   }
+
+  return IfKind;
 }
 
 static bool isGoogScope(const UnwrappedLine &Line) {
   // FIXME: Closure-library specific stuff should not be hard-coded but be
   // configurable.
   if (Line.Tokens.size() < 4)
     return false;
   auto I = Line.Tokens.begin();
if (NextMustBeValue && !NextEndsTemplateExpr && !PreviousStartsTemplateExpr &&
        Previous->isOneOf(tok::r_square, tok::r_paren, tok::plusplus,
                          tok::minusminus)))
     return addUnwrappedLine();
   if ((PreviousMustBeValue || Previous->is(tok::r_paren)) &&
       isJSDeclOrStmt(Keywords, Next))
     return addUnwrappedLine();
 }
 
-void UnwrappedLineParser::parseStructuralElement(bool IsTopLevel) {
+void UnwrappedLineParser::parseStructuralElement(IfStmtKind *IfKind,
+                                                 bool IsTopLevel) {
   if (Style.Language == FormatStyle::LK_TableGen &&
       FormatTok->is(tok::pp_include)) {
     nextToken();
     if (FormatTok->is(tok::string_literal))
       nextToken();
     addUnwrappedLine();
     return;
   }
if (Style.Language == FormatStyle::LK_Java || Style.isJavaScript() ||
       nextToken();
     else
       parseAccessSpecifier();
     return;
   case tok::kw_if:
     if (Style.isJavaScript() && Line->MustBeDeclaration)
       // field/method declaration.
       break;
-    parseIfThenElse();
+    parseIfThenElse(IfKind);
     return;
   case tok::kw_for:
   case tok::kw_while:
     if (Style.isJavaScript() && Line->MustBeDeclaration)
       // field/method declaration.
       break;
     parseForOrWhileLoop();
     return;
case tok::at:
       break;
     default:
       nextToken();
       break;
     }
   } while (!eof());
 }
 
-void UnwrappedLineParser::parseIfThenElse() {
+void UnwrappedLineParser::keepAncestorBraces() {
+  const int MaxNestingLevels = 2;
+  const int Size = NestedTooDeep.size();
+  if (Size >= MaxNestingLevels)
+    NestedTooDeep[Size - MaxNestingLevels] = true;
+  NestedTooDeep.push_back(false);
+}
+
+static bool resetBraces(FormatToken *LeftBrace) {
+  assert(LeftBrace);
+  assert(LeftBrace->is(tok::l_brace));
+
+  FormatToken *RightBrace = LeftBrace->MatchingParen;
+  if (!RightBrace) {
+    assert(!LeftBrace->Optional);
+    return false;
+  }
+
+  assert(RightBrace->is(tok::r_brace));
+  assert(RightBrace->MatchingParen == LeftBrace);
+  assert(LeftBrace->Optional == RightBrace->Optional);
+
+  const bool KeepBraces = !LeftBrace->Optional;
+
+  LeftBrace->Optional = false;
+  LeftBrace->MatchingParen = nullptr;
+  RightBrace->Optional = false;
+  RightBrace->MatchingParen = nullptr;
+
+  return KeepBraces;
+}
+
+static void markOptionalBraces(FormatToken *LeftBrace) {
+  if (!LeftBrace)
+    return;
+
+  assert(LeftBrace->is(tok::l_brace));
+
+  FormatToken *RightBrace = LeftBrace->MatchingParen;
+  if (!RightBrace) {
+    assert(!LeftBrace->Optional);
+    return;
+  }
+
+  assert(RightBrace->is(tok::r_brace));
+  assert(RightBrace->MatchingParen == LeftBrace);
+
+  LeftBrace->Optional = true;
+  RightBrace->Optional = true;
+}
+
+FormatToken *UnwrappedLineParser::parseIfThenElse(IfStmtKind *IfKind,
+                                                  bool KeepBraces) {
   auto HandleAttributes = [this]() {
     // Handle AttributeMacro, e.g. `if (x) UNLIKELY`.
     if (FormatTok->is(TT_AttributeMacro))
       nextToken();
     // Handle [[likely]] / [[unlikely]] attributes.
     if (FormatTok->is(tok::l_square) && tryToParseSimpleAttribute())
       parseSquare();
   };
 
   assert(FormatTok->Tok.is(tok::kw_if) && "'if' expected");
   nextToken();
   if (FormatTok->Tok.isOneOf(tok::kw_constexpr, tok::identifier))
     nextToken();
   if (FormatTok->Tok.is(tok::l_paren))
     parseParens();
   HandleAttributes();
+
+  keepAncestorBraces();
   bool NeedsUnwrappedLine = false;
+
+  bool KeepIfBraces = false;
+  FormatToken *IfLeftBrace = nullptr;
+  IfStmtKind IfBlockKind = IfStmtKind::NotIf;
   if (FormatTok->Tok.is(tok::l_brace)) {
+    KeepIfBraces = resetBraces(FormatTok);
+    IfLeftBrace = FormatTok;
     CompoundStatementIndenter Indenter(this, Style, Line->Level);
-    parseBlock();
+    IfBlockKind = parseBlock();
     if (Style.BraceWrapping.BeforeElse)
       addUnwrappedLine();
     else
       NeedsUnwrappedLine = true;
   } else {
     addUnwrappedLine();
     ++Line->Level;
     parseStructuralElement();
     --Line->Level;
   }
+
+  assert(!NestedTooDeep.empty());
+  KeepIfBraces = KeepIfBraces || (IfLeftBrace && !IfLeftBrace->MatchingParen) ||
+                 NestedTooDeep.back() ||
+                 IfBlockKind == IfStmtKind::IfOnly || // LLVM
+                 IfBlockKind == IfStmtKind::IfElseIf;
+
+  bool KeepElseBraces = false;
+  FormatToken *ElseLeftBrace = nullptr;
+  IfStmtKind Kind = IfStmtKind::IfOnly;
   if (FormatTok->Tok.is(tok::kw_else)) {
+    NestedTooDeep.back() = false;
+    Kind = IfStmtKind::IfElse;
+    // KeepIfBraces = KeepIfBraces || IfBlockKind == IfStmtKind::IfOnly;
     nextToken();
     HandleAttributes();
     if (FormatTok->Tok.is(tok::l_brace)) {
+      KeepElseBraces = resetBraces(FormatTok);
+      ElseLeftBrace = FormatTok;
       CompoundStatementIndenter Indenter(this, Style, Line->Level);
-      parseBlock();
+      if (parseBlock() == IfStmtKind::IfOnly)
+        Kind = IfStmtKind::IfElseIf;
       addUnwrappedLine();
     } else if (FormatTok->Tok.is(tok::kw_if)) {
       FormatToken *Previous = Tokens->getPreviousToken();
-      bool PrecededByComment = Previous && Previous->is(tok::comment);
-      if (PrecededByComment) {
+      const bool IsPrecededByComment = Previous && Previous->is(tok::comment);
+      if (IsPrecededByComment) {
         addUnwrappedLine();
         ++Line->Level;
       }
-      parseIfThenElse();
-      if (PrecededByComment)
+      Kind = IfStmtKind::IfElseIf;
+      const bool TooDeep = NestedTooDeep.pop_back_val();
+      ElseLeftBrace =
+          parseIfThenElse(/*IfKind=*/nullptr, KeepBraces || KeepIfBraces);
+      NestedTooDeep.push_back(TooDeep);
+      if (IsPrecededByComment)
         --Line->Level;
     } else {
       addUnwrappedLine();
       ++Line->Level;
       parseStructuralElement();
       if (FormatTok->is(tok::eof))
         addUnwrappedLine();
       --Line->Level;
     }
-  } else if (NeedsUnwrappedLine) {
+  } else {
+    KeepIfBraces = KeepIfBraces || IfBlockKind == IfStmtKind::IfElse;
+    if (NeedsUnwrappedLine)
       addUnwrappedLine();
   }
+
+  assert(!NestedTooDeep.empty());
+  KeepElseBraces = KeepElseBraces ||
+                   (ElseLeftBrace && !ElseLeftBrace->MatchingParen) ||
+                   NestedTooDeep.back();
+
+  NestedTooDeep.pop_back();
+
+  if (!KeepBraces && !KeepIfBraces && !KeepElseBraces) {
+    markOptionalBraces(IfLeftBrace);
+    markOptionalBraces(ElseLeftBrace);
+  } else if (IfLeftBrace) {
+    FormatToken *IfRightBrace = IfLeftBrace->MatchingParen;
+    if (IfRightBrace) {
+      assert(IfRightBrace->MatchingParen == IfLeftBrace);
+      assert(!IfLeftBrace->Optional);
+      assert(!IfRightBrace->Optional);
+      IfLeftBrace->MatchingParen = nullptr;
+      IfRightBrace->MatchingParen = nullptr;
+    }
+  }
+
+  if (IfKind)
+    *IfKind = Kind;
+
+  return IfLeftBrace;
 }
 
 void UnwrappedLineParser::parseTryCatch() {
   assert(FormatTok->isOneOf(tok::kw_try, tok::kw___try) && "'try' expected");
   nextToken();
   bool NeedsUnwrappedLine = false;
   if (FormatTok->is(tok::colon)) {
     // We are in a function try block, what comes is an initializer list.
while (FormatTok->is(tok::identifier)) {
       while (FormatTok->is(tok::comma))
         nextToken();
     }
   }
   // Parse try with resource.
   if (Style.Language == FormatStyle::LK_Java && FormatTok->is(tok::l_paren)) {
     parseParens();
   }
+
+  keepAncestorBraces();
   if (FormatTok->is(tok::l_brace)) {
     CompoundStatementIndenter Indenter(this, Style, Line->Level);
     parseBlock();
     if (Style.BraceWrapping.BeforeCatch) {
       addUnwrappedLine();
     } else {
       NeedsUnwrappedLine = true;
     }
   } else if (!FormatTok->is(tok::kw_catch)) {
if (!(FormatTok->isOneOf(tok::kw_catch, Keywords.kw___except,
            FormatTok->Tok.isObjCAtKeyword(tok::objc_finally))))
       break;
     nextToken();
     while (FormatTok->isNot(tok::l_brace)) {
       if (FormatTok->is(tok::l_paren)) {
         parseParens();
         continue;
       }
-      if (FormatTok->isOneOf(tok::semi, tok::r_brace, tok::eof))
+      if (FormatTok->isOneOf(tok::semi, tok::r_brace, tok::eof)) {
+        NestedTooDeep.pop_back();
         return;
+      }
       nextToken();
     }
     NeedsUnwrappedLine = false;
     CompoundStatementIndenter Indenter(this, Style, Line->Level);
     parseBlock();
     if (Style.BraceWrapping.BeforeCatch)
       addUnwrappedLine();
     else
       NeedsUnwrappedLine = true;
   }
+  NestedTooDeep.pop_back();
+
   if (NeedsUnwrappedLine)
     addUnwrappedLine();
 }
 
 void UnwrappedLineParser::parseNamespace() {
   assert(FormatTok->isOneOf(tok::kw_namespace, TT_NamespaceMacro) &&
          "'namespace' expected");
 
void UnwrappedLineParser::parseForOrWhileLoop() {
   nextToken();
   // JS' for await ( ...
   if (Style.isJavaScript() && FormatTok->is(Keywords.kw_await))
     nextToken();
   if (Style.isCpp() && FormatTok->is(tok::kw_co_await))
     nextToken();
   if (FormatTok->Tok.is(tok::l_paren))
     parseParens();
+
+  keepAncestorBraces();
   if (FormatTok->Tok.is(tok::l_brace)) {
+    const bool KeepBraces = resetBraces(FormatTok);
+    FormatToken *LeftBrace = FormatTok;
     CompoundStatementIndenter Indenter(this, Style, Line->Level);
     parseBlock();
+    assert(!NestedTooDeep.empty());
+    if (!KeepBraces && !NestedTooDeep.back())
+      markOptionalBraces(LeftBrace);
     addUnwrappedLine();
   } else {
     addUnwrappedLine();
     ++Line->Level;
     parseStructuralElement();
     --Line->Level;
   }
+  NestedTooDeep.pop_back();
 }
 
 void UnwrappedLineParser::parseDoWhile() {
   assert(FormatTok->Tok.is(tok::kw_do) && "'do' expected");
   nextToken();
+
+  keepAncestorBraces();
   if (FormatTok->Tok.is(tok::l_brace)) {
     CompoundStatementIndenter Indenter(this, Style, Line->Level);
     parseBlock();
     if (Style.BraceWrapping.BeforeWhile)
       addUnwrappedLine();
   } else {
     addUnwrappedLine();
     ++Line->Level;
     parseStructuralElement();
     --Line->Level;
   }
+  NestedTooDeep.pop_back();
 
   // FIXME: Add error handling.
   if (!FormatTok->Tok.is(tok::kw_while)) {
     addUnwrappedLine();
     return;
   }
 
   // If in Whitesmiths mode, the line with the while() needs to be indented
void UnwrappedLineParser::parseCaseLabel() {
   parseLabel();
 }
 
 void UnwrappedLineParser::parseSwitch() {
   assert(FormatTok->Tok.is(tok::kw_switch) && "'switch' expected");
   nextToken();
   if (FormatTok->Tok.is(tok::l_paren))
     parseParens();
+
+  keepAncestorBraces();
   if (FormatTok->Tok.is(tok::l_brace)) {
     CompoundStatementIndenter Indenter(this, Style, Line->Level);
     parseBlock();
     addUnwrappedLine();
   } else {
     addUnwrappedLine();
     ++Line->Level;
     parseStructuralElement();
     --Line->Level;
   }
+  NestedTooDeep.pop_back();
 }
 
 void UnwrappedLineParser::parseAccessSpecifier() {
   nextToken();
   // Understand Qt's slots.
   if (FormatTok->isOneOf(Keywords.kw_slots, Keywords.kw_qslots))
     nextToken();
   // Otherwise, we don't know what it is, and we'd better keep the next token.
if (FormatTok->is(tok::l_brace)) {
       addUnwrappedLine();
       break;
     } else {
       nextToken();
     }
   }
 
   // Parse the class body after the enum's ";" if any.
   parseLevel(/*HasOpeningBrace=*/true);
   nextToken();
   --Line->Level;
   addUnwrappedLine();
 }
 
 void UnwrappedLineParser::parseRecord(bool ParseAsExpr) {
   const FormatToken &InitialToken = *FormatTok;
   nextToken();

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, ParsesConfigurationBools) {
   CHECK_PARSE_BOOL(IndentGotoLabels);
   CHECK_PARSE_BOOL(IndentRequires);
   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
   CHECK_PARSE_BOOL(ReflowComments);
+  CHECK_PARSE_BOOL(RemoveBracesLLVM);
   CHECK_PARSE_BOOL(SortUsingDeclarations);
   CHECK_PARSE_BOOL(SpacesInParentheses);
   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
verifyFormat("try {\n"
                Style);
 
   verifyFormat("try {\n"
                "  doA();\n"
                "} catch (Exception &e) {}\n",
                Style);
 }
 
+TEST_F(FormatTest, RemoveBraces) {
+  FormatStyle Style = getLLVMStyle();
+  Style.RemoveBracesLLVM = true;
+
+  // The following eight test cases are fully-braced versions of the examples at
+  // "llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-
+  // statement-bodies-of-if-else-loop-statements".
+
+  // 1. Omit the braces, since the body is simple and clearly associated with
+  // the if.
+  EXPECT_EQ("if (isa<FunctionDecl>(D))\n"
+            "  handleFunctionDecl(D);\n"
+            "else if (isa<VarDecl>(D))\n"
+            "  handleVarDecl(D);",
+            format("if (isa<FunctionDecl>(D)) {\n"
+                   "  handleFunctionDecl(D);\n"
+                   "} else if (isa<VarDecl>(D)) {\n"
+                   "  handleVarDecl(D);\n"
+                   "}",
+                   Style));
+
+  // 2. Here we document the condition itself and not the body.
+  verifyFormat("if (isa<VarDecl>(D)) {\n"
+               "  // It is necessary that we explain the situation with this\n"
+               "  // surprisingly long comment, so it would be unclear\n"
+               "  // without the braces whether the following statement is in\n"
+               "  // the scope of the `if`.\n"
+               "  // Because the condition is documented, we can't really\n"
+               "  // hoist this comment that applies to the body above the\n"
+               "  // if.\n"
+               "  handleOtherDecl(D);\n"
+               "}",
+               Style);
+
+  // 3. Use braces on the outer `if` to avoid a potential dangling else
+  // situation.
+  EXPECT_EQ("if (isa<VarDecl>(D)) {\n"
+            "  for (auto *A : D.attrs())\n"
+            "    if (shouldProcessAttr(A))\n"
+            "      handleAttr(A);\n"
+            "}",
+            format("if (isa<VarDecl>(D)) {\n"
+                   "  for (auto *A : D.attrs()) {\n"
+                   "    if (shouldProcessAttr(A)) {\n"
+                   "      handleAttr(A);\n"
+                   "    }\n"
+                   "  }\n"
+                   "}",
+                   Style));
+
+  // 4. Use braces for the `if` block to keep it uniform with the else block.
+  verifyFormat("if (isa<FunctionDecl>(D)) {\n"
+               "  handleFunctionDecl(D);\n"
+               "} else {\n"
+               "  // In this else case, it is necessary that we explain the\n"
+               "  // situation with this surprisingly long comment, so it\n"
+               "  // would be unclear without the braces whether the\n"
+               "  // following statement is in the scope of the `if`.\n"
+               "  handleOtherDecl(D);\n"
+               "}",
+               Style);
+
+  // 5. This should also omit braces.  The `for` loop contains only a single
+  // statement, so it shouldn't have braces.  The `if` also only contains a
+  // single simple statement (the for loop), so it also should omit braces.
+  EXPECT_EQ("if (isa<FunctionDecl>(D))\n"
+            "  for (auto *A : D.attrs())\n"
+            "    handleAttr(A);",
+            format("if (isa<FunctionDecl>(D)) {\n"
+                   "  for (auto *A : D.attrs()) {\n"
+                   "    handleAttr(A);\n"
+                   "  }\n"
+                   "}",
+                   Style));
+
+  // 6. Use braces for the outer `if` since the nested `for` is braced.
+  verifyFormat("if (isa<FunctionDecl>(D)) {\n"
+               "  for (auto *A : D.attrs()) {\n"
+               "    // In this for loop body, it is necessary that we explain\n"
+               "    // the situation with this surprisingly long comment,\n"
+               "    // forcing braces on the `for` block.\n"
+               "    handleAttr(A);\n"
+               "  }\n"
+               "}",
+               Style);
+
+  // 7. Use braces on the outer block because there are more than two levels of
+  // nesting.
+  EXPECT_EQ("if (isa<FunctionDecl>(D)) {\n"
+            "  for (auto *A : D.attrs())\n"
+            "    for (ssize_t i : llvm::seq<ssize_t>(count))\n"
+            "      handleAttrOnDecl(D, A, i);\n"
+            "}",
+            format("if (isa<FunctionDecl>(D)) {\n"
+                   "  for (auto *A : D.attrs()) {\n"
+                   "    for (ssize_t i : llvm::seq<ssize_t>(count)) {\n"
+                   "      handleAttrOnDecl(D, A, i);\n"
+                   "    }\n"
+                   "  }\n"
+                   "}",
+                   Style));
+
+  // 8. Use braces on the outer block because of a nested `if`, otherwise the
+  // compiler would warn: `add explicit braces to avoid dangling else`
+  EXPECT_EQ("if (auto *D = dyn_cast<FunctionDecl>(D)) {\n"
+            "  if (shouldProcess(D))\n"
+            "    handleVarDecl(D);\n"
+            "  else\n"
+            "    markAsIgnored(D);\n"
+            "}",
+            format("if (auto *D = dyn_cast<FunctionDecl>(D)) {\n"
+                   "  if (shouldProcess(D)) {\n"
+                   "    handleVarDecl(D);\n"
+                   "  } else {\n"
+                   "    markAsIgnored(D);\n"
+                   "  }\n"
+                   "}",
+                   Style));
+
+  EXPECT_EQ("if (a)\n"
+            "  b; // comment\n"
+            "else if (c)\n"
+            "  d; /* comment */\n"
+            "else\n"
+            "  e;",
+            format("if (a) {\n"
+                   "  b; // comment\n"
+                   "} else if (c) {\n"
+                   "  d; /* comment */\n"
+                   "} else {\n"
+                   "  e;\n"
+                   "}",
+                   Style));
+
+  verifyFormat("if (a) {\n"
+               "  b;\n"
+               "  c;\n"
+               "} else if (d) {\n"
+               "  e;\n"
+               "}",
+               Style);
+
+  verifyFormat("if (a) {\n"
+               "#undef NDEBUG\n"
+               "  b;\n"
+               "} else {\n"
+               "  c;\n"
+               "}",
+               Style);
+
+  verifyFormat("if (a) {\n"
+               "  // comment\n"
+               "} else if (b) {\n"
+               "  c;\n"
+               "}",
+               Style);
+
+  verifyFormat("if (a) {\n"
+               "  b;\n"
+               "} else {\n"
+               "  { c; }\n"
+               "}",
+               Style);
+
+  EXPECT_EQ("if (a) {\n"
+            "  if (b) // comment\n"
+            "    c;\n"
+            "} else if (d) {\n"
+            "  e;\n"
+            "}",
+            format("if (a) {\n"
+                   "  if (b) { // comment\n"
+                   "    c;\n"
+                   "  }\n"
+                   "} else if (d) {\n"
+                   "  e;\n"
+                   "}",
+                   Style));
+
+  verifyFormat("if (a) {\n"
+               "  if (b) {\n"
+               "    c;\n"
+               "    // comment\n"
+               "  } else if (d) {\n"
+               "    e;\n"
+               "  }\n"
+               "}",
+               Style);
+
+  EXPECT_EQ("if (a) {\n"
+            "  if (b)\n"
+            "    c;\n"
+            "}",
+            format("if (a) {\n"
+                   "  if (b) {\n"
+                   "    c;\n"
+                   "  }\n"
+                   "}",
+                   Style));
+
+  EXPECT_EQ("if (a)\n"
+            "  if (b)\n"
+            "    c;\n"
+            "  else\n"
+            "    d;\n"
+            "else\n"
+            "  e;",
+            format("if (a) {\n"
+                   "  if (b) {\n"
+                   "    c;\n"
+                   "  } else {\n"
+                   "    d;\n"
+                   "  }\n"
+                   "} else {\n"
+                   "  e;\n"
+                   "}",
+                   Style));
+
+  EXPECT_EQ("if (a) {\n"
+            "  // comment\n"
+            "  if (b)\n"
+            "    c;\n"
+            "  else if (d)\n"
+            "    e;\n"
+            "} else {\n"
+            "  g;\n"
+            "}",
+            format("if (a) {\n"
+                   "  // comment\n"
+                   "  if (b) {\n"
+                   "    c;\n"
+                   "  } else if (d) {\n"
+                   "    e;\n"
+                   "  }\n"
+                   "} else {\n"
+                   "  g;\n"
+                   "}",
+                   Style));
+
+  EXPECT_EQ("if (a)\n"
+            "  b;\n"
+            "else if (c)\n"
+            "  d;\n"
+            "else\n"
+            "  e;",
+            format("if (a) {\n"
+                   "  b;\n"
+                   "} else {\n"
+                   "  if (c) {\n"
+                   "    d;\n"
+                   "  } else {\n"
+                   "    e;\n"
+                   "  }\n"
+                   "}",
+                   Style));
+
+  EXPECT_EQ("if (a) {\n"
+            "  if (b)\n"
+            "    c;\n"
+            "  else if (d)\n"
+            "    e;\n"
+            "} else {\n"
+            "  g;\n"
+            "}",
+            format("if (a) {\n"
+                   "  if (b)\n"
+                   "    c;\n"
+                   "  else {\n"
+                   "    if (d)\n"
+                   "      e;\n"
+                   "  }\n"
+                   "} else {\n"
+                   "  g;\n"
+                   "}",
+                   Style));
+
+  EXPECT_EQ("if (a)\n"
+            "  b;\n"
+            "else if (c)\n"
+            "  while (d)\n"
+            "    e;\n"
+            "// comment",
+            format("if (a)\n"
+                   "{\n"
+                   "  b;\n"
+                   "} else if (c) {\n"
+                   "  while (d) {\n"
+                   "    e;\n"
+                   "  }\n"
+                   "}\n"
+                   "// comment",
+                   Style));
+
+  verifyFormat("if (a) {\n"
+               "  b;\n"
+               "} else if (c) {\n"
+               "  d;\n"
+               "} else {\n"
+               "  e;\n"
+               "  g;\n"
+               "}",
+               Style);
+
+  verifyFormat("if (a) {\n"
+               "  b;\n"
+               "} else if (c) {\n"
+               "  d;\n"
+               "} else {\n"
+               "  e;\n"
+               "} // comment",
+               Style);
+}
+
 } // namespace
 } // namespace format
 } // namespace clang