[clang-format] Add Insert/Remove Braces option

[MyDeveloperDay]

Summary

InsertBraces will insert braces for single line control flow statements (currently if/else/for).
It currently accepts the following options:

• Never - Keeps the current behavior and never add braces (also default value)
• Always - Always add braces to single lines after the control flow statement
• WrapLikely - If the line after the control flow statement is not braced and likely to wrap, braces will be added
• Remove - Always remove braces to single line flow control

[curdeius]

There's a clang-tidy check for it.
And clang-format should not, IMO, add not remove tokens but only handle whitespace.

[tiagoma]

Some background might be useful. I work at Microsoft (Office to be precise). We have our own fork of LLVM internally and I am starting to upstream some of the changes in our fork.

There's a clang-tidy check for it.

Yes - readability-braces-around-statements. I would argue that clang-tidy is a heavyweight tool for this.

And clang-format should not, IMO, add not remove tokens but only handle whitespace.

I don't think token operations are novel, see the InsertTrailingCommas, JavaScriptQuotes, SortUsingDeclarations, FixNamespaceComments options. Also, keep in mind that this option is fairly self contained (it happens before the Formatter pass) and it is off by default.

[curdeius]

True, I was aware of the presence of some of these options, thank you for indicating others. I'm not yet entirely convinced, especially that clang-tidy behaviour would be possibly different.

Anyway, a few comments just from the first glance.

clang/docs/ClangFormatStyleOptions.rst

2774

Shouldn't it be consistent with clang-tidy? So instead of an enum, this option might take a number of lines that will trigger brace insertion? None may be sth like -1. "Likely" is very vague.

clang/lib/Format/Format.cpp

1954

Nit: put full stop at the end of the comments.

1968

And make the comments full phrases, starting with a capital letter.

[tiagoma]

clang/docs/ClangFormatStyleOptions.rst

2774

I am not sure this is possible. clang-tidy assumes the code is already formatted, we cannot assume that in clang-format. This pass runs before the formatter pass, so basing the behavior on line count would lead to different behavior across runs. For example:

Assuming we can set this option to 2 lines and we have the following code:

if (condition)
	very_long_line_that_will_wrap(arg, arg, arg ,arg)

first run:

if (condition)
	very_long_line_that_will_wrap(
		arg, arg, arg ,arg)

second run:

if (condition) {
	very_long_line_that_will_wrap(
		arg, arg, arg ,arg)}
}

Likely is indeed vague by design. We "guess" that it will wrap in the formatter pass based on the current column value. See Format.cpp @ 1707. What might happen is that the line is incorrectly indentented and the wrapping never actually happens.

[tiagoma]

Update comments

[MyDeveloperDay]

I think this is one of those reviews that ultimately I think would be useful if we could ensure it works 100% correctly, but I think it goes against the original ethos of clang-format and I think if @djasper or @klimek the original authors were here they'd probably push back.

This reminds me of my own work for a East/West fixer, it proved to be a bit too controversial for some, despite being off by default. but I also agree clang-format has been inserting and moving code around for some time, so its no longer just a whitespace manipulation tool.

I do like this, and I agree clang-tidy is often too heavy weight ( For my source tree which is millions of line of code running clang-tidy over the whole thing is just not possible). I personally run "clang-format -n" over my entire tree every night to sanity check it, this feature would allow me to enforce the use of {} without which I've found over the years is often a source of bugs.

lets see if others have an opinion

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

22345

can you use verifyFormat() instead of EXPECT_EQ?

22420

are you testing do/while?

[MyDeveloperDay]

I wonder if we should consider suggesting a different type of tool for clang

clang-reformat

A place where changes such as this and east/west fixer could be actively encouraged.

[curdeius]

Hmm, interesting idea. Do you have anything more precise in mind? Would it be an "augmented" clang-format? I.e. it will have all its options and some additional ones? Or rather more independent tool? Or clang-format's experimental field?

[steveire]

In D95168#2532258, @MyDeveloperDay wrote:

I wonder if we should consider suggesting a different type of tool for clang

clang-reformat

A place where changes such as this and east/west fixer could be actively encouraged.

I don't think this should be done. These kinds of things should be in clang-format. One of the advantages of this and east/west const being in clang-format is that editors, CI systems and other tools have clang-format support. They would be unlikely to get support for a new tool. There are plenty of clang tools which exist but which don't get enough attention to get support in editors CI tools etc.

[curdeius]

In D95168#2532410, @steveire wrote:

In D95168#2532258, @MyDeveloperDay wrote:

I wonder if we should consider suggesting a different type of tool for clang

clang-reformat

A place where changes such as this and east/west fixer could be actively encouraged.

I don't think this should be done. These kinds of things should be in clang-format. One of the advantages of this and east/west const being in clang-format is that editors, CI systems and other tools have clang-format support. They would be unlikely to get support for a new tool. There are plenty of clang tools which exist but which don't get enough attention to get support in editors CI tools etc.

Not saying that I'm in favour of creating another tool, but...
I believe that such a tool, if it were pretty much a drop-in replacement of clang-format, it could profit from the current tooling support.
Why? Because most of them let you define the clang-format binary path.

[steveire]

In D95168#2532458, @curdeius wrote:

In D95168#2532410, @steveire wrote:

In D95168#2532258, @MyDeveloperDay wrote:

I wonder if we should consider suggesting a different type of tool for clang

clang-reformat

A place where changes such as this and east/west fixer could be actively encouraged.

I don't think this should be done. These kinds of things should be in clang-format. One of the advantages of this and east/west const being in clang-format is that editors, CI systems and other tools have clang-format support. They would be unlikely to get support for a new tool. There are plenty of clang tools which exist but which don't get enough attention to get support in editors CI tools etc.

Not saying that I'm in favour of creating another tool, but...
I believe that such a tool, if it were pretty much a drop-in replacement of clang-format, it could profit from the current tooling support.

If it's a drop in replacement (does everything clang-format does and more), what's the benefit for that cost?

[MyDeveloperDay]

If it's a drop in replacement (does everything clang-format does and more), what's the benefit for that cost?

I'm in agreement here, It was a suggestion just to appease those who don't like clang-format doing such things, but still allowing us to add code changing capabilities. (which I don't understand why that isn't controlled simply by turning the capability off.)

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

22328

can these all be verifyFormats

22420

whilst people discuss the ethics of modifying the code ;-)

Can you add some comment based examples

if (condition) // my test
      you_do_you();

if (condition)
      you_do_you(); // my test

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

22420

bonus points..

if /*condition*/ (condition) /*condition*/
/*condition*/      you_do_you(); /*condition*/

[MyDeveloperDay]

I'm just going to say this here, but LLVM doesn't like the use of braces on single lines (I don't actually like that myself, but I go with the convention when I remember),

but this is followed only if the reviewer catches it, but by and large its super easy for them to get missed, it took me seconds to find an example..

I would love to see the end for the need for the "elide braces" comment in code reviews, by having an ability to "RemoveBraces"

i.e. this feature should be able to remove the {} in this case

// Defaults that differ when not C++.
if (Language == FormatStyle::LK_TableGen) {
  LLVMStyle.SpacesInContainerLiterals = false;
}

[njames93]

clang/unittests/Format/FormatTest.cpp

22420

Should also add test for chained conditionals just to make sure the semantics of the code doesn't change.

if (A)
  if (B)
    callAB();
  else
    callA();
else if (B)
  callB();
else
  call();

[tiagoma]

Add more tests

[tiagoma]

clang/unittests/Format/FormatTest.cpp

22420

do/while are not supported in it's current form. We would need to change the logic to add more state. I can have a look at it after this patch is accepted.

22420

This specific test will fail by itself, ie:

StringRef Test = "if /*condition*/ (condition)  /*condition*/\n"
                 "  /*condition*/ you_do_you(); /*condition*/";

verifyFormat(Test);

AFAICT it is because test::messUp causes the 2nd and 3rd comment to stay on the same line. I added a variation of the test.

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

22420

The problem with this statement is as soon as you commit, we'd get that defect raised, that is ok its just are you going to stay around long enough to finish it completely? ;-) if not then this puts burden on those who hang out here all the time.

Ideally its probably worth following through with a complete implementation before landing (or as best you can), there is no rush right?

[tiagoma]

Add support for do/while

[MyDeveloperDay]

LGTM, we need to run this on a large code base to ensure it doesn't make mistakes in real code, but I think this looks good.

[HazardyKnusperkeks]

Although verifyFormat is nice, I would add some EXPECT_EQ to show that the braces are really inserted.

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

22329

Can you just put the code inline in the verifyFormat, please copy the convention in the file

[MyDeveloperDay]

clang/docs/ClangFormatStyleOptions.rst

2751

I'm not convinced this code has been generated via doc/tools/dump_format_style.py can you confirm this or did you make this change by hand?

[MyDeveloperDay]

could you add tests showing the impact of using [[likely]] and [[unlikely]]

[MyDeveloperDay]

Any thoughts about actually removing braces? eliding braces on single line functions would be very useful for LLVM, its like the most common review comment!

[MyDeveloperDay]

@tiagoma are you still interested in pursuing this? I have some suggestions

1. I'd like to move the BraceInserter Into its own .cpp and .h files (like I did with the QualifierAlignmentFixer)
2. I'd like to move the unit tests into their own .cpp file (because I think we need to actually unit tests their functions of BraceInserter more than just testing if via verfiyFormat and I think its cleaner as FormatTest.cpp is very large)
3. I'd like to see what it would take to remove braces, (eliding the braces on small ifs and control statements is about the number one review comments in LLVM)

I feel like we've general community agreement that clang-format can modify the tokens (following the RFC around QualifierAlignmentFixer) as long as the documentation carries a clear warning and its off by default.

If you are no longer interested in landing this, I am happy to consider taking it on.

[MyDeveloperDay]

clang/include/clang/Format/Format.h

1064

Please add something like this

/// \warning
///  Setting ``InsertBraces``  to something other than `Never`, COULD
///  lead to incorrect code formatting due to incorrect decisions made due to
///  clang-formats lack of full semantic information.
///  As such extra care should be taken to review code changes made by the use
///  of this option.
/// \endwarning
/// \version 14

clang/lib/Format/Format.cpp

222

I'd like to see "Remove"

[MyDeveloperDay]

clang/lib/Format/Format.cpp

3004

Why is this just C++ (LK_Cpp is also Objective C++ and C and Objective C I think)

Why wouldn't I want to add "{}" in C# and/or JavaScript?

clang/unittests/Format/FormatTest.cpp

78

Something here doesn't seem correct, I don't really understand the comment?

[MyDeveloperDay]

This patch needs rebasing to main

[owenpan]

In D95168#3038531, @MyDeveloperDay wrote:

@tiagoma are you still interested in pursuing this? I have some suggestions

1. I'd like to move the BraceInserter Into its own .cpp and .h files (like I did with the QualifierAlignmentFixer)
2. I'd like to move the unit tests into their own .cpp file (because I think we need to actually unit tests their functions of BraceInserter more than just testing if via verfiyFormat and I think its cleaner as FormatTest.cpp is very large)
3. I'd like to see what it would take to remove braces, (eliding the braces on small ifs and control statements is about the number one review comments in LLVM)

Eliding braces would be much more complicated and should be tackled separately. Below are just some examples:

void f() {
  // Braces can be removed:
  if (a) {
    b;
  } else if (c) {
    d;
  } else {
    e;
  }

  if (a) {
    b;
    c;
  } else if (d) { // Braces may be removed depending on the style.
#undef NDEBUG
    e;
  } else if (g) {
    // comment
  } else {
    {
      h;
    }
  }

  if (a) {
    if (b) { // Braces can be removed.
      c;
    }
  } else if (d) { // Braces may be removed depending on the style.
    e;
  }

  if (a) { // Braces can be removed if the dangling-else warning can be ignored.
    if (b) { // Braces may be removed depending on the style.
      c;
      // comment
    } else if (d) { // Braces may be removed depending on the style.
      e;
    }
  }

  // Braces can be removed:
  if (a) {
    if (b) {
      c;
    }
  }

  // Braces may be removed depending on the style:
  if (a) {
    if (b) {
      c;
    } else {
      d;
    }
  } else {
    e;
  }

  if (a) { // Braces may be removed depending on the style.
    // Braces can be removed:
    if (b) {
      c;
    } else if (d) {
      e;
    }
  } else { // Braces may be removed depending on the style.
    g;
  }

  // Braces can be removed:
  if (a) {
    b;
  } else {
    if (c) {
      d;
    } else {
      e;
    }
  }

I have an experimental implementation that reformats the above to the following (avoiding the dangling-else warning, matching braces of if and else, etc.):

void f() {
  // Braces can be removed:
  if (a)
    b;
  else if (c)
    d;
  else
    e;

  if (a) {
    b;
    c;
  } else if (d) { // Braces may be removed depending on the style.
#undef NDEBUG
    e;
  } else if (g) {
    // comment
  } else {
    { h; }
  }

  if (a) {
    if (b) // Braces can be removed.
      c;
  } else if (d) { // Braces may be removed depending on the style.
    e;
  }

  if (a) { // Braces can be removed if the dangling-else warning can be ignored.
    if (b) { // Braces may be removed depending on the style.
      c;
      // comment
    } else if (d) { // Braces may be removed depending on the style.
      e;
    }
  }

  // Braces can be removed:
  if (a)
    if (b)
      c;

  // Braces may be removed depending on the style:
  if (a)
    if (b)
      c;
    else
      d;
  else
    e;

  if (a) { // Braces may be removed depending on the style.
    // Braces can be removed:
    if (b)
      c;
    else if (d)
      e;
  } else { // Braces may be removed depending on the style.
    g;
  }

  // Braces can be removed:
  if (a)
    b;
  else if (c)
    d;
  else
    e;

[MyDeveloperDay]

In D95168#3039033, @owenpan wrote:

In D95168#3038531, @MyDeveloperDay wrote:

@tiagoma are you still interested in pursuing this? I have some suggestions

1. I'd like to move the BraceInserter Into its own .cpp and .h files (like I did with the QualifierAlignmentFixer)
2. I'd like to move the unit tests into their own .cpp file (because I think we need to actually unit tests their functions of BraceInserter more than just testing if via verfiyFormat and I think its cleaner as FormatTest.cpp is very large)
3. I'd like to see what it would take to remove braces, (eliding the braces on small ifs and control statements is about the number one review comments in LLVM)

Eliding braces would be much more complicated and should be tackled separately. Below are just some examples:

I agree with that, to be honest I work in an organization where we'd only ever be inserting them, but I think anyone conforming to LLVM style could appreciate a removal option, but yes lets do that separately.

[MyDeveloperDay]

This will fail in the presence of macro line concatination

if (x)
        return true;
else
        return false;

#define RETURN(x) \
if (x) \
    return true;\
else \
     return false;

it will remove the trailing \

if (x) {
  return true;
} else {
  return false;
}

#define RETURN(x)                                                              \
  if (x) {                                                                     \
    return true;
}
else {
  return false;
}

[MyDeveloperDay]

ping @tiagoma are you still around to pursue this feature request or can this be commandeered?

[tiagoma]

go for it

[MyDeveloperDay]

In D95168#3060296, @tiagoma wrote:

go for it

@tiagoma to be honest this actually works pretty well, I've been using it in a private build on the large project I work on and I've been ripping through some of the legacy code adding braces like its gone out of fashion, it works a treat, I see only a couple of issues

1. the macros
2. nested missing braces

if (x)
  for(int i....)
        foo()

In the later case it will only do the inner for() (I haven't actually tested if I apply it again will it find the outer case)

Its substantially quicker than trying to do the same with clang-tidy, and from my experience with clang-tidy its actually a little more accurate! (sorry just saying!), as often the fix-it get a bit confused.

The recent RFC on the use of clang-format to modify code (https://lists.llvm.org/pipermail/llvm-dev/2021-August/152070.html) means that I think we can move forward with "modifing changes" like this one, where previously I would have been hesitant.

From what I can tell you see, to exclude this from C# and Javascript (but I see no real reason why not do you?)

I'm happy to take a look further if you don't have time (I'll of course keep any credit to you!, this is a great idea).

[MyDeveloperDay]

To confirm

if (x)
    for(int i=0;i<10;i++)
        foo();

will be transformed to

if (x)
  for (int i = 0; i < 10; i++) {
    foo();
  }

but this itself will NOT be transformed to

if (x) {
  for (int i = 0; i < 10; i++) {
    foo();
  }
}

So definitely we are going to miss some cases.

[MyDeveloperDay]

I'd like to carry the mantle for this, before making any further changes I'd like to address some of the review comments

1. Add documentation warning about a modifying change (as agreed by the RFC)
2. Add version introduced information
3. Fix issue with Macro continuation (don't add the \n before the } unless you see a \\ line comment, otherwise let clang-format deal with the \n depending on the BraceWrapping style
4. Add unit tests for Macro continuation and Comment handling
5. Allow InsertBraces in other languages

TODO:

• break out into its own file (Format.cpp is getting too big)
• Look further into possible Removal (I have an idea for how this might be possible, and super useful for LLVM where we don't like single if {} ), I'd like to round out on this before introducing the options rather than having to change them later

• Should we add the possibility of removal should we change the option name to "AutomaticBraces" (thoughts?)
• @tiagoma please add your name and email addreess to this review so when the time comes to land this I can attribute to you as "Author".

[HazardyKnusperkeks]

In D95168#3099739, @MyDeveloperDay wrote:

I'd like to carry the mantle for this, before making any further changes I'd like to address some of the review comments

1. Add documentation warning about a modifying change (as agreed by the RFC)
2. Add version introduced information
3. Fix issue with Macro continuation (don't add the \n before the } unless you see a \\ line comment, otherwise let clang-format deal with the \n depending on the BraceWrapping style
4. Add unit tests for Macro continuation and Comment handling
5. Allow InsertBraces in other languages

TODO:

• break out into its own file (Format.cpp is getting too big)

This also holds for FormatTest.cpp.

• Look further into possible Removal (I have an idea for how this might be possible, and super useful for LLVM where we don't like single if {} ), I'd like to round out on this before introducing the options rather than having to change them later

Yeah we should have that.

• Should we add the possibility of removal should we change the option name to "AutomaticBraces" (thoughts?)

Name change is good, the options then also need to be renamed.

• @tiagoma please add your name and email addreess to this review so when the time comes to land this I can attribute to you as "Author".

clang/include/clang/Format/Format.h

1065

Could we just add a big notification on top, that some specially marked options may break the code, and then only mark them, so one does not need to write that much for all possible options?

[owenpan]

In D95168#3099739, @MyDeveloperDay wrote:

• Look further into possible Removal (I have an idea for how this might be possible, and super useful for LLVM where we don't like single if {} ), I'd like to round out on this before introducing the options rather than having to change them later

• Should we add the possibility of removal should we change the option name to "AutomaticBraces" (thoughts?)

As mentioned in D95168#3039033, I think it would be better to handle the removal separately. The LLVM Coding Standards has an entire section about this. Some of the listed exceptions/examples there can make things more difficult.

[HazardyKnusperkeks]

In D95168#3099920, @owenpan wrote:

In D95168#3099739, @MyDeveloperDay wrote:

• Look further into possible Removal (I have an idea for how this might be possible, and super useful for LLVM where we don't like single if {} ), I'd like to round out on this before introducing the options rather than having to change them later

• Should we add the possibility of removal should we change the option name to "AutomaticBraces" (thoughts?)

As mentioned in D95168#3039033, I think it would be better to handle the removal separately. The LLVM Coding Standards has an entire section about this. Some of the listed exceptions/examples there can make things more difficult.

Difficult, yes. But I think it should be in one option.
It hasn't to be implemented everything right from the start. And we could give all those cases a name and a different setting, so that the entire document would be mappable to a .clang-format with a convenience setting for all options at once.

[MyDeveloperDay]

In D95168#3099920, @owenpan wrote:

In D95168#3099739, @MyDeveloperDay wrote:

• Look further into possible Removal (I have an idea for how this might be possible, and super useful for LLVM where we don't like single if {} ), I'd like to round out on this before introducing the options rather than having to change them later

• Should we add the possibility of removal should we change the option name to "AutomaticBraces" (thoughts?)

As mentioned in D95168#3039033, I think it would be better to handle the removal separately. The LLVM Coding Standards has an entire section about this. Some of the listed exceptions/examples there can make things more difficult.

I'm thinking more about not adding a "InsertBraces" only later to find it should have been InsertRemoveBraces or AutomaticBraces i.e. I want to have some idea as to how this might work, if it might be possible even if we land separately.

[owenpan]

In D95168#3100376, @HazardyKnusperkeks wrote:

In D95168#3099920, @owenpan wrote:

In D95168#3099739, @MyDeveloperDay wrote:

• Look further into possible Removal (I have an idea for how this might be possible, and super useful for LLVM where we don't like single if {} ), I'd like to round out on this before introducing the options rather than having to change them later

• Should we add the possibility of removal should we change the option name to "AutomaticBraces" (thoughts?)

As mentioned in D95168#3039033, I think it would be better to handle the removal separately. The LLVM Coding Standards has an entire section about this. Some of the listed exceptions/examples there can make things more difficult.

Difficult, yes. But I think it should be in one option.
It hasn't to be implemented everything right from the start. And we could give all those cases a name and a different setting, so that the entire document would be mappable to a .clang-format with a convenience setting for all options at once.

What I meant to say is that we should have a separate patch for the removal implementation. I was not opposed to putting both insertion and removal under an enum option like "AutoBraces: Never, Insert, Remove, LLVM, ..."

[owenpan]

In D95168#3100969, @MyDeveloperDay wrote:

In D95168#3099920, @owenpan wrote:

In D95168#3099739, @MyDeveloperDay wrote:

• Look further into possible Removal (I have an idea for how this might be possible, and super useful for LLVM where we don't like single if {} ), I'd like to round out on this before introducing the options rather than having to change them later

• Should we add the possibility of removal should we change the option name to "AutomaticBraces" (thoughts?)

As mentioned in D95168#3039033, I think it would be better to handle the removal separately. The LLVM Coding Standards has an entire section about this. Some of the listed exceptions/examples there can make things more difficult.

I'm thinking more about not adding a "InsertBraces" only later to find it should have been InsertRemoveBraces or AutomaticBraces i.e. I want to have some idea as to how this might work, if it might be possible even if we land separately.

I think the InsertBraces options can be handled by an enum, but the RemoveBraces options most likely will use a struct. Does it make sense to have both turned on in the same configuration?

[MyDeveloperDay]

In D95168#3102247, @owenpan wrote:

In D95168#3100969, @MyDeveloperDay wrote:

In D95168#3099920, @owenpan wrote:

In D95168#3099739, @MyDeveloperDay wrote:

• Look further into possible Removal (I have an idea for how this might be possible, and super useful for LLVM where we don't like single if {} ), I'd like to round out on this before introducing the options rather than having to change them later

• Should we add the possibility of removal should we change the option name to "AutomaticBraces" (thoughts?)

As mentioned in D95168#3039033, I think it would be better to handle the removal separately. The LLVM Coding Standards has an entire section about this. Some of the listed exceptions/examples there can make things more difficult.

I'm thinking more about not adding a "InsertBraces" only later to find it should have been InsertRemoveBraces or AutomaticBraces i.e. I want to have some idea as to how this might work, if it might be possible even if we land separately.

I think the InsertBraces options can be handled by an enum, but the RemoveBraces options most likely will use a struct. Does it make sense to have both turned on in the same configuration?

Then this is definitely why we want to think about these now and NOT leave them to a separate review after the Insert case is committed.

From my experience options seem to have a life cycle, it seems many of our options have gone via this route and thinking about this a little more upfront might help us in the long run.

bool -> enum -> struct

I can already envisage some people only wanting inserting of braces on if's and not for's or whiles's (so the options we have are likely not enough as an enum anyway), I think the WrapLikely was the beginning of that.,

If we think remove braces would be a struct then we'd better go for a struct now and not later so there is some symmetry, I'm slightly wondering what would be in the struct? but taking a look at the implementation I've been working on there are a couple of things I noticed already.

1. Do we want to remove {} from an else or elseif when the if needs braces

if (x==1) {
   foo();
   bar();
}
else  if (x==2)
  baz();
else 
  foo();

2. Do we want to remove braces from a commented if (this can throw your eye out when looking)

if (x==1)
   // some longish comment
   return x;

3. Do we want sub scope to be removed of braces too?

if (x==1)
    for (int i=0;i<10;i++)
              foo();

4. Do we want to prevent the remove for MultiLine scope, where what follows would be spread over multiple lines (a little like the comment really)

    if (x== 1)
        os << "This is a very very very long" 
             << data
             << "More data"
             << "endl;"
`

[MyDeveloperDay]

This is a demo of what I mean D113000: [clang-format] NOT FOR COMMIT - Demo of AutomaticBraces: Remove you can see its pretty aggressive, I could kind of imagine people wanting a little more control

Sometimes this feels inconsistent

and in this case the expression seem so separated from the if() that you might want to keep the {}

[MyDeveloperDay]

Move BraceInserter into its own file and tests

Add experimental support for "Remove"

[MyDeveloperDay]

Add some more testcases to catch handling removing {} from the nested if, but not the outer if

[HazardyKnusperkeks]

In D95168#3102247, @owenpan wrote:

In D95168#3100969, @MyDeveloperDay wrote:

In D95168#3099920, @owenpan wrote:

In D95168#3099739, @MyDeveloperDay wrote:

• Look further into possible Removal (I have an idea for how this might be possible, and super useful for LLVM where we don't like single if {} ), I'd like to round out on this before introducing the options rather than having to change them later

• Should we add the possibility of removal should we change the option name to "AutomaticBraces" (thoughts?)

As mentioned in D95168#3039033, I think it would be better to handle the removal separately. The LLVM Coding Standards has an entire section about this. Some of the listed exceptions/examples there can make things more difficult.

I'm thinking more about not adding a "InsertBraces" only later to find it should have been InsertRemoveBraces or AutomaticBraces i.e. I want to have some idea as to how this might work, if it might be possible even if we land separately.

I think the InsertBraces options can be handled by an enum, but the RemoveBraces options most likely will use a struct. Does it make sense to have both turned on in the same configuration?

I'm in favor of a struct of enums:

AutomaticBraces:
  AfterIf: OnlyIfElse
  AfterElse: Remove #this is obviously only to remove, if the else body is a single line
  AfterWhile: ...

And we can gradually add new enumerators to handle the delicate nuances of adding or removing the braces.
And we should add them one after another.

clang/include/clang/Format/Format.h

3735

Resort ;)

clang/lib/Format/BraceInserter.cpp

105 ↗

(On Diff #384171)

Remove the {
Oh the irony. :)

clang/lib/Format/BraceInserter.h

1 ↗

(On Diff #384171)

Inserter is misleading, if we want it to be able to remove.

[owenpan]

In D95168#3102511, @MyDeveloperDay wrote:

Then this is definitely why we want to think about these now and NOT leave them to a separate review after the Insert case is committed.

We can just leave a placeholder for the RemoveBraces options and deal with them when we get there. Unless I misunderstood, your suggestion of the AutomaticBraces option (with enum values Insert, Remove, LLVM, etc) would accomplish that.

If we think remove braces would be a struct then we'd better go for a struct now and not later so there is some symmetry, I'm slightly wondering what would be in the struct?

I already had an implementation of RemoveBraces for the LLVM style (minus some exceptions). I started with an enum to accommodate different levels of aggressiveness of removal with LLVM at the minimum end. After looking at several prominent styles, I realized that a struct would work better.

1. Do we want to remove {} from an else or elseif when the if needs braces

if (x==1) {
   foo();
   bar();
}
else  if (x==2)
  baz();
else 
  foo();

2. Do we want to remove braces from a commented if (this can throw your eye out when looking)

if (x==1)
   // some longish comment
   return x;

3. Do we want sub scope to be removed of braces too?

if (x==1)
    for (int i=0;i<10;i++)
              foo();

4. Do we want to prevent the remove for MultiLine scope, where what follows would be spread over multiple lines (a little like the comment really)

    if (x== 1)
        os << "This is a very very very long" 
             << data
             << "More data"
             << "endl;"
`

I've seen both yes and no for all the above.

[MyDeveloperDay]

I already had an implementation of RemoveBraces for the LLVM style (minus some exceptions).

Why not share the implementation in a review then we can combine them here.

[owenpan]

In D95168#3102550, @MyDeveloperDay wrote:

This is a demo of what I mean D113000: [clang-format] NOT FOR COMMIT - Demo of AutomaticBraces: Remove you can see its pretty aggressive, I could kind of imagine people wanting a little more control

Sometimes this feels inconsistent

and in this case the expression seem so separated from the if() that you might want to keep the {}

In my experience, the simplest thing to do is to remove all optional braces as allowed by the language syntax. When you want to add exceptions for matching if-else braces, avoiding dangling-else warnings, etc, things get much more complicated very quickly. :)

[MyDeveloperDay]

I'm in favor of a struct of enums:

AutomaticBraces:
  AfterIf: OnlyIfElse
  AfterElse: Remove #this is obviously only to remove, if the else body is a single line
  AfterWhile: ...

And we can gradually add new enumerators to handle the delicate nuances of adding or removing the braces.
And we should add them one after another.

I like this approach, let me switch over to a struct (that might take me a bit, I'll reorder on the way), I do sort of feel this is for both Inserting/Removing of Braces at the same time should also be the reverse.

i.e. we may not always want to add braces (but allow similar rules to LLVM style)

So a clang-format could be a combination of adding and removing braces depending on the location and usecase, hence in my view why we might as well do this all in one review. I personally wouldn't want 1 implementation for inserting and 1 for removing hence they need to share that configuration.

@tiagoma, I'm going to change the name of the class and file too, just to make that its both Inserting and Removing.

[MyDeveloperDay]

In my experience, the simplest thing to do is to remove all optional braces as allowed by the language syntax. When you want to add exceptions for matching if-else braces, avoiding dangling-else warnings, etc, things get much more complicated very quickly. :)

I can well imagine. I already hit this once where I mutated the TokenAnnotator.cpp incorrect (which caused the unit tests to break). TokenAnnotator.cpp is if/else hell as far as I'm concerned, its a really good test best for some of this stuff!

[owenpan]

In D95168#3105340, @MyDeveloperDay wrote:

I already had an implementation of RemoveBraces for the LLVM style (minus some exceptions).

Why not share the implementation in a review then we can combine them here.

I want to try implementing the remaining exceptions for LLVM and tighten some loose ends before submitting the patch. I don't think we should combine Insert and Remove (even if it's technically possible) before each has been tested against a large codebase.

[MyDeveloperDay]

clang/lib/Format/BraceInserter.cpp

105 ↗

(On Diff #384171)

I know!, I'm glad you liked that! (sorry!)

To be honest I can't help myself when I work in LLVM, because this is our company's style, but really this is why I'm keen to add "Remove" support because I need something to keep me honest.

I'm not going to feel that bad, I've run this ability to remove {} over parts of the LLVM code already, its "carnage!!!"

We ALL haven't been keeping a consistent style, My only hope is as we cover some of the LLVM specific cases the amount of churn will reduce (but don't hold your breath!!!)

But I think this is why this is a good idea of @tiagoma , having something like this in clang-format is quite an eye opener. I've already used the Insert ability in our company's legacy code and its great!

[MyDeveloperDay]

This is very much a WIP, updating the patch (as hit a waypoint), and would like others to have a chance to comment on possible configuration options

• move the options to a struct.
• handle non removal in the presence of a comment
• brining in the concept of handling different control statement types differently (i.e. you might want braces removed only from if statements but not the others)
• add unit tests to codify (https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements)

AutomaticBraces:
    AfterIf: RemoveNoComment
    AfterElse: RemoveNoComment
    AfterFor: Remove
    AfterWhile: Remove
    AfterDo: Remove

Not completely sure I like the RemoveNoComment, we could handle the non removal if there is a comment case globally (same with the "scope depth") e.g.

And like BreakBeforeBraces I sort of feel that we might want to have some predefines i.e. (LLVM/Custom/Gnu?)

At present its very much Insert or Remove, still to add tests for selective insertion, but I wanted to discuss the configuration options first.

AutomaticBraces: LLVM/Custom
AutomaticBracesOption:
    AfterIf: Remove
    AfterElse: Remove
    AfterFor: Insert
    AfterWhile: Insert
    AfterDo: Insert
    RemovalIfCommentPresent:false
    MaxScopeDepth: 2

RemoveNoComment is the concept of handling a comment after the if() differently

if (x) {
   // comment
   return x;
}
`

I have also run this on some of the sections of LLVM code (Basic/Lexer/Format) to try and catch any potential code change issues.

Also dogfooded it by formatting BraceInserter.cpp.

[HazardyKnusperkeks]

Not yet done reviewing everything.

clang/include/clang/Format/Format.h

946

Maybe differentiate between single line and multi line comments?

3695–3696

Add it here

clang/lib/Format/BraceInserter.cpp

21–56 ↗

(On Diff #384715)

How about something like that?

114 ↗

(On Diff #384715)

(Please read for the comment below.) Could also go into a function and use the same mapping.

165 ↗

(On Diff #384715)

Is this supposed to be used?

174 ↗

(On Diff #384715)

current is not null

178 ↗

(On Diff #384715)

!current->Next also holds always

194 ↗

(On Diff #384715)

And then this is dead code

211 ↗

(On Diff #384715)

Is there always a next?

284 ↗

(On Diff #384715)

This should go into a function, which maybe uses a mapping of the token type to the member used for checking.

[MyDeveloperDay]

clang/include/clang/Format/Format.h

946

do you think we might want do remove braces from:

if (x) {
  // Remove the braces
  return true;
}

but not from?

if (x) {
  // Don't Remove the braces
  // As the comment it longer
  return true;
}

I could see that

3695–3696

So I notice we don't do this for BraceWrapping, I was going to swing by on this one and see why not.

3735

ouch! thats someone elses bug... but I can look at it.

clang/lib/Format/BraceInserter.h

1 ↗

(On Diff #384171)

Yes I'm going to rename the files, AutomaticBraces.cpp/.h AutomaticBracesTests.cpp what do you think?

[MyDeveloperDay]

clang/docs/ClangFormatStyleOptions.rst

1131

Oops missed regenerating this.! (next time around)

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

946

Basically yeah. I for one will only turn on insert, but I think a differentiation here is good.

3695–3696

Most likely a bug.

3735

I wrote that when AutomaticBraces was after Language.

Yeah one could and should resort the whole list, but that was not what I meant.

clang/lib/Format/BraceInserter.h

1 ↗

(On Diff #384171)

Sounds good.

[MyDeveloperDay]

Add more LLVM rules, and don't remove when there are single or multi lines comments

[MyDeveloperDay]

clang/lib/Format/BraceInserter.cpp

21–56 ↗

(On Diff #384715)

I think for now

bool SupportsAnyAutomaticBraces(FormatStyle &Style, bool insertion) {
  if (   Style.AutomaticBraces.AfterIf == FormatStyle::BIS_Leave
      && Style.AutomaticBraces.AfterFor == FormatStyle::BIS_Leave
      && Style.AutomaticBraces.AfterWhile == FormatStyle::BIS_Leave
      && Style.AutomaticBraces.AfterDo == FormatStyle::BIS_Leave
      && Style.AutomaticBraces.AfterElse == FormatStyle::BIS_Leave)
      return false;

  if (!insertion){
    if (Style.AutomaticBraces.AfterIf != FormatStyle::BIS_Remove)
    && Style.AutomaticBraces.AfterFor != FormatStyle::BIS_Remove)
    && Style.AutomaticBraces.AfterWhile != FormatStyle::BIS_Remove)
    && Style.AutomaticBraces.AfterDo != FormatStyle::BIS_Remove)
    && Style.AutomaticBraces.AfterElse != FormatStyle::BIS_Remove)
      return false;
  }
  return true;
}

Should cover it.

[HazardyKnusperkeks]

Should I copy my comments on the old file?

clang/lib/Format/BraceInserter.cpp

21–56 ↗

(On Diff #384715)

Yeah, but I like my variant better. :)

clang/lib/Format/Format.cpp

2461

I think this should keep its brace.

[MyDeveloperDay]

clang/lib/Format/BraceInserter.cpp

21–56 ↗

(On Diff #384715)

but I'm not clever enough to understand it!

[MyDeveloperDay]

Abandoning as replaced with a better solution D120217: [clang-format] Add an option to insert braces after control statements

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: c++
     void only_writes_to_buffer(char *__output buffer);
 
   In the .clang-format configuration file, this can be configured like:
 
   .. code-block:: yaml
 
     AttributeMacros: ['__capability', '__output', '__ununsed']
 
+**AutomaticBraces** (``BraceInsertionStyle``) :versionbadge:`clang-format 14`
+  If set to ``WrapLikely`` will insert braces if the line after the
+  control flow statement is likely to wrap.
+  If set to ``Always`` will always insert braces.
+  If set to ``Remove`` will remove braces where possible.
+  The default is the disabled value of ``BIS_Leave``.
+
+  .. warning:: 
+
+   Setting ``AutomaticBraces``  to something other than `Leave`, COULD
+   lead to incorrect code formatting due to incorrect decisions made due to
+   clang-formats lack of complete semantic information.
+   As such extra care should be taken to review code changes made by the use
+   of this option.
+
+  Possible values:
+
+  * ``BIS_Leave`` (in configuration: ``Leave``)
+    Do not insert or remove braces.
+
+  * ``BIS_Always`` (in configuration: ``Always``)
+    Always insert braces.
+
+  * ``BIS_WrapLikely`` (in configuration: ``WrapLikely``)
+    Insert braces if the line is likely to wrap.
+
+  * ``BIS_Remove`` (in configuration: ``Remove``)
+    Always remove braces.
+
+
+
 **BinPackArguments** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``false``, a function call's arguments will either be all on the
   same line or will have one line each.
 
   .. code-block:: c++
 
     true:
     void f() {
.. code-block:: c++
      true:
      LoooooooooooooooooooooooooooooooooooooooongReturnType
          LoooooooooooooooooooooooooooooooongFunctionDeclaration();
 
      false:
      LoooooooooooooooooooooooooooooooooooooooongReturnType
      LoooooooooooooooooooooooooooooooongFunctionDeclaration();
 
 **InsertTrailingCommas** (``TrailingCommaStyle``) :versionbadge:`clang-format 12`
   If set to ``TCS_Wrapped`` will insert trailing commas in container
   literals (arrays and objects) that wrap across multiple lines.
   It is currently only available for JavaScript
   and disabled by default ``TCS_None``.
   ``InsertTrailingCommas`` cannot be used together with ``BinPackArguments``
   as inserting the comma disables bin-packing.
 
   .. code-block:: c++
 
     TSC_Wrapped:
     const someArray = [
     aaaaaaaaaaaaaaaaaaaaaaaaaa,
     aaaaaaaaaaaaaaaaaaaaaaaaaa,
     aaaaaaaaaaaaaaaaaaaaaaaaaa,
     //                        ^ inserted
     ]
 
   Possible values:
 
   * ``TCS_None`` (in configuration: ``None``)
     Do not insert trailing commas.
 
   * ``TCS_Wrapped`` (in configuration: ``Wrapped``)
     Insert trailing commas in container literals that were wrapped over
     multiple lines. Note that this is conceptually incompatible with
     bin-packing, because the trailing comma is used as an indicator
     that a container should be formatted one-per-line (i.e. not bin-packed).
     So inserting a trailing comma counteracts bin-packing.
 
 
 

clang/docs/ReleaseNotes.rst

- Option ``QualifierAligment`` has been added in order to auto-arrange the
   `const` `volatile` `static` `inline` `constexpr` `restrict`
   in variable and parameter declarations to be either ``Right`` aligned
   or ``Left`` aligned or ``Custom`` using ``QualifierOrder``.
 
 - Option ``QualifierOrder`` has been added to allow the order
   `const` `volatile` `static` `inline` `constexpr` `restrict`
   to be controlled relative to the `type`.
 
+- Option ``AutomaticBraces`` has been added to allow the insertion
+  and removal of {} from if/for/while scope
+
 libclang
 --------
 
 - ...
 
 Static Analyzer
 ---------------
 

clang/include/clang/Format/Format.h

struct FormatStyle {
   /// In the .clang-format configuration file, this can be configured like:
   /// \code{.yaml}
   ///   AttributeMacros: ['__capability', '__output', '__ununsed']
   /// \endcode
   ///
   /// \version 12
   std::vector<std::string> AttributeMacros;
 
+  // Number of comments lines that signal the braces should
+  // be kept on removal     .
+  enum AutomaticBraceCommentAllowance {
+    // The presense of a any number of comment means we will not
+    // remove the brace
+    ABCA_Any,
+    // The braces will be removed for single line comments only
+    ABCA_SingleLineOnly,
+    // The braces will be removed for only multi line comments only
+    ABCA_MultipleLinesOnly
+  };
+
+  enum AutomaticBracesStyle {
+    /// Do not insert or remove braces.
+    BIS_Leave = 0,
+    /// Always insert braces.
+    BIS_Always,
+    /// Insert braces if the line is likely to wrap.
+    BIS_WrapLikely,
+    /// Always remove braces.
+    BIS_Remove
+  };
+
+  /// The style of inserting braces in control flow statements.
+  struct AutomaticBracesOptions {
+    // Insert/Remove after if()
+    AutomaticBracesStyle AfterIf;
+
+    // Insert/Remove after for()
+    AutomaticBracesStyle AfterFor;
+
+    // Insert/Remove after while()
+    AutomaticBracesStyle AfterWhile;
+
+    // Insert/Remove after do
+    AutomaticBracesStyle AfterDo;
+
+    // Insert/Remove after else
+    AutomaticBracesStyle AfterElse;
+
+    // Controls Removal of braces from commented scope
+    AutomaticBraceCommentAllowance BraceRemovalComments;
+
+    bool operator==(const AutomaticBracesOptions &Other) const {
+      return AfterIf == Other.AfterIf && AfterFor == Other.AfterFor &&
+             AfterWhile == Other.AfterWhile && AfterDo == Other.AfterDo &&
+             AfterElse == Other.AfterElse &&
+             BraceRemovalComments == Other.BraceRemovalComments;
+    }
+  };
+
+  /// If set to ``WrapLikely`` will insert braces if the line after the
+  /// control flow statement is likely to wrap.
+  /// If set to ``Always`` will always insert braces.
+  /// If set to ``Remove`` will remove braces where possible.
+  /// The default is the disabled value of ``BIS_Leave``.
+  /// \warning
+  ///  Setting ``AutomaticBraces``  to something other than `Leave`, COULD
+  ///  lead to incorrect code formatting due to incorrect decisions made due to
+  ///  clang-formats lack of complete semantic information.
+  ///  As such extra care should be taken to review code changes made by the use
+  ///  of this option.
+  /// \endwarning
+  /// \version 14
+  AutomaticBracesOptions AutomaticBraces;
+
   /// If ``false``, a function call's arguments will either be all on the
   /// same line or will have one line each.
   /// \code
   ///   true:
   ///   void f() {
   ///     f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
   ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
   ///   }
struct FormatStyle {
   ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
   ///
   ///   false:
   ///   void f(int aaaaaaaaaaaaaaaaaaaa,
   ///          int aaaaaaaaaaaaaaaaaaaa,
   ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
   /// \endcode
   /// \version 3.7
   bool BinPackParameters;
 
   /// The style of wrapping parameters on the same line (bin-packed) or
   /// on one line each.
   enum BinPackStyle : unsigned char {
     /// Automatically determine parameter bin-packing behavior.
     BPS_Auto,
     /// Always bin-pack parameters.
     BPS_Always,
     /// Never bin-pack parameters.
return AccessModifierOffset == R.AccessModifierOffset &&
                R.AllowShortIfStatementsOnASingleLine &&
            AllowShortLambdasOnASingleLine == R.AllowShortLambdasOnASingleLine &&
            AllowShortLoopsOnASingleLine == R.AllowShortLoopsOnASingleLine &&
            AlwaysBreakAfterReturnType == R.AlwaysBreakAfterReturnType &&
            AlwaysBreakBeforeMultilineStrings ==
                R.AlwaysBreakBeforeMultilineStrings &&
            AlwaysBreakTemplateDeclarations ==
                R.AlwaysBreakTemplateDeclarations &&
            AttributeMacros == R.AttributeMacros &&
+           AutomaticBraces == R.AutomaticBraces &&
            BinPackArguments == R.BinPackArguments &&
            BinPackParameters == R.BinPackParameters &&
            BreakBeforeBinaryOperators == R.BreakBeforeBinaryOperators &&
            BreakBeforeBraces == R.BreakBeforeBraces &&
            BreakBeforeConceptDeclarations == R.BreakBeforeConceptDeclarations &&
            BreakBeforeTernaryOperators == R.BreakBeforeTernaryOperators &&
            BreakConstructorInitializers == R.BreakConstructorInitializers &&
            CompactNamespaces == R.CompactNamespaces &&
return AccessModifierOffset == R.AccessModifierOffset &&
            IncludeStyle.IncludeIsMainSourceRegex ==
                R.IncludeStyle.IncludeIsMainSourceRegex &&
            IndentAccessModifiers == R.IndentAccessModifiers &&
            IndentCaseLabels == R.IndentCaseLabels &&
            IndentCaseBlocks == R.IndentCaseBlocks &&
            IndentGotoLabels == R.IndentGotoLabels &&
            IndentPPDirectives == R.IndentPPDirectives &&
            IndentExternBlock == R.IndentExternBlock &&
-           IndentRequires == R.IndentRequires && IndentWidth == R.IndentWidth &&
-           Language == R.Language &&
+           IndentRequires == R.IndentRequires &&
            IndentWrappedFunctionNames == R.IndentWrappedFunctionNames &&
+           IndentWidth == R.IndentWidth &&
            JavaImportGroups == R.JavaImportGroups &&
            JavaScriptQuotes == R.JavaScriptQuotes &&
            JavaScriptWrapImports == R.JavaScriptWrapImports &&
            KeepEmptyLinesAtTheStartOfBlocks ==
                R.KeepEmptyLinesAtTheStartOfBlocks &&
            LambdaBodyIndentation == R.LambdaBodyIndentation &&
-           MacroBlockBegin == R.MacroBlockBegin &&
+           Language == R.Language && MacroBlockBegin == R.MacroBlockBegin &&
            MacroBlockEnd == R.MacroBlockEnd &&
            MaxEmptyLinesToKeep == R.MaxEmptyLinesToKeep &&
            NamespaceIndentation == R.NamespaceIndentation &&
            NamespaceMacros == R.NamespaceMacros &&
            ObjCBinPackProtocolList == R.ObjCBinPackProtocolList &&
            ObjCBlockIndentWidth == R.ObjCBlockIndentWidth &&
            ObjCBreakBeforeNestedBlockParam ==
                R.ObjCBreakBeforeNestedBlockParam &&

clang/lib/Format/AutomaticBraces.h

+//===--- AutomaticBraces.h - Format C++ code ------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file defines the class for inserting braces
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_FORMAT_AUTOMATICBRACES_H
+#define LLVM_CLANG_LIB_FORMAT_AUTOMATICBRACES_H
+
+#include "TokenAnalyzer.h"
+
+namespace clang {
+namespace format {
+
+class AutomaticBraces : public TokenAnalyzer {
+public:
+  AutomaticBraces(const Environment &Env, const FormatStyle &Style)
+      : TokenAnalyzer(Env, Style) {}
+
+  std::pair<tooling::Replacements, unsigned>
+  analyze(TokenAnnotator &Annotator,
+          SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
+          FormatTokenLexer &Tokens) override;
+
+private:
+  void insertBraces(SmallVectorImpl<AnnotatedLine *> &Lines,
+                    tooling::Replacements &Result);
+
+  void removeBraces(SmallVectorImpl<AnnotatedLine *> &Lines,
+                    tooling::Replacements &Result);
+
+  std::set<SourceLocation> Done;
+};
+
+} // namespace format
+} // namespace clang
+
+#endif

clang/lib/Format/AutomaticBraces.cpp

+//===--- AutmaticBraces.cpp - Format C++ code -----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements functions declared in Format.h. This will be
+/// split into separate files as we go.
+///
+//===----------------------------------------------------------------------===//
+
+#include "AutomaticBraces.h"
+#include "clang/Format/Format.h"
+
+namespace clang {
+namespace format {
+// Are any of the options set for insertion/removal?
+bool SupportsAnyAutomaticBraces(FormatStyle &Style, bool insertion) {
+  if (insertion) {
+    if (Style.AutomaticBraces.AfterIf == FormatStyle::BIS_Always)
+      return true;
+    if (Style.AutomaticBraces.AfterIf == FormatStyle::BIS_WrapLikely)
+      return true;
+    if (Style.AutomaticBraces.AfterFor == FormatStyle::BIS_Always)
+      return true;
+    if (Style.AutomaticBraces.AfterFor == FormatStyle::BIS_WrapLikely)
+      return true;
+    if (Style.AutomaticBraces.AfterWhile == FormatStyle::BIS_Always)
+      return true;
+    if (Style.AutomaticBraces.AfterWhile == FormatStyle::BIS_WrapLikely)
+      return true;
+    if (Style.AutomaticBraces.AfterDo == FormatStyle::BIS_Always)
+      return true;
+    if (Style.AutomaticBraces.AfterDo == FormatStyle::BIS_WrapLikely)
+      return true;
+    if (Style.AutomaticBraces.AfterElse == FormatStyle::BIS_Always)
+      return true;
+    if (Style.AutomaticBraces.AfterElse == FormatStyle::BIS_WrapLikely)
+      return true;
+  } else {
+    if (Style.AutomaticBraces.AfterIf >= FormatStyle::BIS_Remove)
+      return true;
+    if (Style.AutomaticBraces.AfterFor >= FormatStyle::BIS_Remove)
+      return true;
+    if (Style.AutomaticBraces.AfterWhile >= FormatStyle::BIS_Remove)
+      return true;
+    if (Style.AutomaticBraces.AfterDo >= FormatStyle::BIS_Remove)
+      return true;
+    if (Style.AutomaticBraces.AfterElse >= FormatStyle::BIS_Remove)
+      return true;
+  }
+  return false;
+}
+
+std::pair<tooling::Replacements, unsigned>
+AutomaticBraces::analyze(TokenAnnotator &Annotator,
+                         SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
+                         FormatTokenLexer &Tokens) {
+  tooling::Replacements Result;
+  if (AffectedRangeMgr.computeAffectedLines(AnnotatedLines)) {
+    if (SupportsAnyAutomaticBraces(Style, /*insertion=*/true))
+      insertBraces(AnnotatedLines, Result);
+
+    if (SupportsAnyAutomaticBraces(Style, /*insertion=*/false))
+      removeBraces(AnnotatedLines, Result);
+  }
+  return {Result, 0};
+}
+
+void AutomaticBraces::insertBraces(SmallVectorImpl<AnnotatedLine *> &Lines,
+                                   tooling::Replacements &Result) {
+  bool InsideCtrlFlowStmt = false;
+
+  tok::TokenKind ControlFlowType = tok::unknown;
+  for (AnnotatedLine *Line : Lines) {
+    insertBraces(Line->Children, Result);
+
+    // Get first token that is not a comment.
+    const FormatToken *FirstTok = Line->First;
+    if (FirstTok->is(tok::comment))
+      FirstTok = FirstTok->getNextNonComment();
+    // The line is a comment.
+    if (!FirstTok)
+      continue;
+    // Get last token that is not a comment.
+    const FormatToken *LastTok = Line->Last;
+    if (LastTok->is(tok::comment))
+      LastTok = LastTok->getPreviousNonComment();
+
+    // If this token starts a control flow stmt, mark it.
+    if (FirstTok->isOneOf(tok::kw_if, tok::kw_else, tok::kw_for, tok::kw_do,
+                          tok::kw_while)) {
+      ControlFlowType = FirstTok->Tok.getKind();
+      InsideCtrlFlowStmt = !LastTok->isOneOf(tok::l_brace, tok::semi);
+      continue;
+    }
+
+    // If the previous line started a ctrl flow block and this line does not
+    // start with curly.
+    if (Line->Affected && !FirstTok->Finalized && InsideCtrlFlowStmt &&
+        FirstTok->isNot(tok::l_brace)) {
+      const SourceLocation startBraceLoc = Line->First->Tok.getLocation();
+      // In some cases clang-format will run the same transform twice which
+      // could lead to adding the curlies twice, skip if we already added one
+      // at this location.
+      if (Done.count(startBraceLoc))
+        break;
+
+      bool ShouldInsert = false;
+
+      switch (ControlFlowType) {
+      case tok::kw_if:
+        ShouldInsert = (Style.AutomaticBraces.AfterIf ==
+                        FormatStyle::AutomaticBracesStyle::BIS_Always);
+        break;
+      case tok::kw_for:
+        ShouldInsert = (Style.AutomaticBraces.AfterFor ==
+                        FormatStyle::AutomaticBracesStyle::BIS_Always);
+        break;
+      case tok::kw_while:
+        ShouldInsert = (Style.AutomaticBraces.AfterWhile ==
+                        FormatStyle::AutomaticBracesStyle::BIS_Always);
+        break;
+      case tok::kw_do:
+        ShouldInsert = (Style.AutomaticBraces.AfterDo ==
+                        FormatStyle::AutomaticBracesStyle::BIS_Always);
+        break;
+      case tok::kw_else:
+        ShouldInsert = (Style.AutomaticBraces.AfterElse ==
+                        FormatStyle::AutomaticBracesStyle::BIS_Always);
+        break;
+      default:
+        ShouldInsert = false;
+        break;
+      }
+
+      if (ShouldInsert || Line->Last->OriginalColumn > Style.ColumnLimit) {
+        Done.insert(startBraceLoc);
+        cantFail(Result.add(tooling::Replacement(Env.getSourceManager(),
+                                                 startBraceLoc, 0, "{")));
+
+        // Mostly we can ignore putting a \n before the } and let the
+        // Formatter handle it, unless the last token is a // comment, Doing
+        // so avoids issues with macro continuation. And a line comment
+        // cannot be part of a continuation.
+        std::string ending = "}";
+        if (Line->Last->is(tok::comment))
+          ending = "\n}";
+        cantFail(Result.add(
+            tooling::Replacement(Env.getSourceManager(),
+                                 Line->Last->Tok.getLocation().getLocWithOffset(
+                                     Line->Last->TokenText.size()),
+                                 0, ending)));
+      }
+    }
+    InsideCtrlFlowStmt = false;
+  }
+}
+
+// Class that allows getting Next over multiple annotated lines
+class NextTokenFetcher {
+  SmallVectorImpl<AnnotatedLine *> &Lines;
+
+public:
+  NextTokenFetcher(SmallVectorImpl<AnnotatedLine *> &Lines) : Lines(Lines) {}
+
+  const FormatToken *getNext(int &Line, const FormatToken *current) {
+    if (current == nullptr)
+      return Lines[0]->First;
+
+    if (current && current->Next)
+      return current->Next;
+
+    // I'm at the end so I can't take the next
+    if (current && !current->Next) {
+      // I'm at the end of all the lines
+      if (current && Lines[Lines.size() - 1]->Last == current)
+        return nullptr;
+
+      for (int NLine = 0; NLine < Lines.size(); NLine++) {
+        FormatToken *tok = Lines[NLine]->Last;
+        if (current == tok) {
+          // if I'm at the end of a line then the next is the
+          // First of the next line
+          return Lines[NLine + 1]->First;
+        }
+      }
+      return nullptr;
+    }
+
+    if (current && !current->Next && Line < (Lines.size() - 1)) {
+      Line++;
+      return Lines[Line]->First;
+    }
+    return current->Next;
+  }
+
+  bool startsSequence(int LineNumber, const FormatToken *RBrace,
+                      tok::TokenKind tok1, tok::TokenKind tok2,
+                      tok::TokenKind tok3, tok::TokenKind tok4) {
+
+    if (!RBrace)
+      return false;
+
+    if (!RBrace->is(tok1))
+      return false;
+    const FormatToken *Next = getNext(LineNumber, RBrace);
+    if (!Next->is(tok2))
+      return false;
+    Next = getNext(LineNumber, Next);
+    if (!Next->is(tok3))
+      return false;
+    Next = getNext(LineNumber, Next);
+    if (!Next->is(tok4))
+      return false;
+    return true;
+  }
+};
+
+// Scan thorough tokens looking for if/for/while etc...
+// find matching ()  e.g. if(), for(), while()
+// if { follows then find matching }
+// count number of ; between { ...  }
+// if number of ; > 1 leave braces
+// if number of ; <= 1 remove braces
+// if {} contain "if" or { before seeing } then don't attempt to
+// remove (This could leads to some false negatives)
+void AutomaticBraces::removeBraces(SmallVectorImpl<AnnotatedLine *> &Lines,
+                                   tooling::Replacements &Result) {
+
+  NextTokenFetcher fetcher(Lines);
+  int LineNumber = 0;
+
+  const FormatToken *NextToken = fetcher.getNext(LineNumber, nullptr);
+  while (NextToken) {
+    const FormatToken *StartingToken = NextToken;
+    NextToken = fetcher.getNext(LineNumber, NextToken);
+
+    // Does the line start with one of the tokens we are expecting to
+    // remove a brace from
+    if (!StartingToken->isOneOf(tok::kw_if, tok::kw_for, tok::kw_else,
+                                tok::kw_while, tok::kw_do))
+      continue;
+
+    const FormatToken *Next = fetcher.getNext(LineNumber, StartingToken);
+    if (!Next) {
+      // We are are the end of the annotated lines.
+      continue;
+    }
+
+    // if/for and while are handled a little differently
+    if (StartingToken->isOneOf(tok::kw_if, tok::kw_for, tok::kw_while)) {
+      if (!Next->is(tok::l_paren) || !Next->MatchingParen)
+        continue;
+      FormatToken *RParen = Next->MatchingParen;
+      const FormatToken *RParenNext = fetcher.getNext(LineNumber, RParen);
+      if (!RParenNext)
+        continue;
+      Next = RParen;
+    } else if (StartingToken->isOneOf(tok::kw_else, tok::kw_do)) {
+      // If we are an `else` or `do` then simple move onto removing the braces.
+      Next = StartingToken;
+    }
+
+    const FormatToken *LBrace = fetcher.getNext(LineNumber, Next);
+    if (!LBrace)
+      continue;
+
+    // We could be `while(x);` or `else if` just continue from
+    // this point if we are.
+    if (LBrace && LBrace->isOneOf(tok::semi, tok::kw_if)) {
+      NextToken = LBrace;
+      continue;
+    }
+
+    if (LBrace && !LBrace->is(tok::l_brace)) {
+      NextToken = LBrace;
+      LBrace = nullptr;
+      continue;
+    }
+
+    // If any single comment stops the removal of braces
+    if (LBrace->startsSequence(tok::l_brace, tok::comment)) {
+      if (Style.AutomaticBraces.BraceRemovalComments ==
+          FormatStyle::AutomaticBraceCommentAllowance::ABCA_Any) {
+        NextToken = LBrace;
+        continue;
+      }
+    }
+    // If any multiple comments stops the removal of braces
+    if (LBrace->startsSequence(tok::l_brace, tok::comment, tok::comment)) {
+      if (Style.AutomaticBraces.BraceRemovalComments ==
+          FormatStyle::AutomaticBraceCommentAllowance::ABCA_SingleLineOnly) {
+        NextToken = LBrace;
+        continue;
+      }
+    }
+
+    // Shoot along until we get to the end brace, but count
+    // the number of functional lines by counting semi's
+    const FormatToken *InnerScopeToken = LBrace;
+
+    int CountSemi = 0;
+    int ScopeInducingTokens = 0;
+    int Scope = 0;
+    while (InnerScopeToken) {
+      InnerScopeToken = fetcher.getNext(LineNumber, InnerScopeToken);
+      if (InnerScopeToken->is(tok::l_brace))
+        Scope++;
+      if (InnerScopeToken->is(tok::r_brace)) {
+        if (Scope == 0)
+          break;
+        Scope--;
+      }
+      if (InnerScopeToken->is(tok::semi))
+        CountSemi++;
+      if (InnerScopeToken->is(tok::comment) &&
+          Style.AutomaticBraces.BraceRemovalComments ==
+              FormatStyle::AutomaticBraceCommentAllowance::ABCA_Any) {
+        LBrace = nullptr;
+        break;
+      }
+      // This can cause a dangling if
+      if (InnerScopeToken->is(tok::kw_if)) {
+        NextToken = InnerScopeToken;
+        ScopeInducingTokens++;
+        break;
+      }
+      if (InnerScopeToken->is(tok::kw_for)) {
+        ScopeInducingTokens++;
+        continue;
+      }
+    }
+
+    // We should now be at the end of at an }.
+    const FormatToken *RBrace = InnerScopeToken;
+    if (!RBrace || !RBrace->is(tok::r_brace))
+      continue;
+
+    // Too many lines.
+    if (CountSemi != 1) {
+      NextToken = RBrace;
+      continue;
+    }
+
+    // Too many levels of scope
+    if (ScopeInducingTokens >= 2) {
+      // Move back to the inner scope.
+      NextToken = LBrace;
+      continue;
+    }
+
+    // Don't remove the braces from if(){} if the else already has braces.
+    if (fetcher.startsSequence(LineNumber, RBrace, tok::r_brace, tok::kw_else,
+                               tok::l_brace, tok::comment)) {
+      RBrace = nullptr;
+      LBrace = nullptr;
+      continue;
+    }
+
+    if (LBrace && RBrace) {
+      // We are finally at the point where we know the positions of {}
+      // And we think this is for just a single line of scope.
+      const SourceLocation startBraceLoc = LBrace->Tok.getLocation();
+      const SourceLocation endBraceLoc = RBrace->Tok.getLocation();
+
+      const char *text = Env.getSourceManager().getCharacterData(
+          endBraceLoc.getLocWithOffset(1));
+
+      // Determine if we need to remove the "}\n" or just "}".
+      int endSize = 1;
+      if (text && text[0] == '\n')
+        endSize++;
+
+      // Remove the { and } (or }\n).
+      cantFail(Result.add(
+          tooling::Replacement(Env.getSourceManager(), startBraceLoc, 1, "")));
+      cantFail(Result.add(tooling::Replacement(Env.getSourceManager(),
+                                               endBraceLoc, endSize, "")));
+      // Move on from where we got to.
+    }
+    NextToken = LBrace;
+  }
+}
+
+} // namespace format
+} // namespace clang

clang/lib/Format/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangFormat
   AffectedRangeManager.cpp
   BreakableToken.cpp
+  AutomaticBraces.cpp
   ContinuationIndenter.cpp
   Format.cpp
   FormatToken.cpp
   FormatTokenLexer.cpp
   MacroExpander.cpp
   NamespaceEndCommentsFixer.cpp
   QualifierAlignmentFixer.cpp
   SortJavaScriptImports.cpp

clang/lib/Format/Format.cpp

 //===--- Format.cpp - Format C++ code -------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements functions declared in Format.h. This will be
 /// split into separate files as we go.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "clang/Format/Format.h"
 #include "AffectedRangeManager.h"
+#include "AutomaticBraces.h"
 #include "BreakableToken.h"
 #include "ContinuationIndenter.h"
 #include "FormatInternal.h"
 #include "FormatTokenLexer.h"
 #include "NamespaceEndCommentsFixer.h"
 #include "QualifierAlignmentFixer.h"
 #include "SortJavaScriptImports.h"
 #include "TokenAnalyzer.h"

 
 template <> struct ScalarEnumerationTraits<FormatStyle::TrailingCommaStyle> {
   static void enumeration(IO &IO, FormatStyle::TrailingCommaStyle &Value) {
     IO.enumCase(Value, "None", FormatStyle::TCS_None);
     IO.enumCase(Value, "Wrapped", FormatStyle::TCS_Wrapped);
   }
 };
 
+template <> struct ScalarEnumerationTraits<FormatStyle::AutomaticBracesStyle> {
+  static void enumeration(IO &IO, FormatStyle::AutomaticBracesStyle &Value) {
+    IO.enumCase(Value, "Leave", FormatStyle::BIS_Leave);
+    IO.enumCase(Value, "Always", FormatStyle::BIS_Always);
+    IO.enumCase(Value, "WrapLikely", FormatStyle::BIS_WrapLikely);
+    IO.enumCase(Value, "Remove", FormatStyle::BIS_Remove);
+  }
+};
+
 template <> struct ScalarEnumerationTraits<FormatStyle::BinaryOperatorStyle> {
   static void enumeration(IO &IO, FormatStyle::BinaryOperatorStyle &Value) {
     IO.enumCase(Value, "All", FormatStyle::BOS_All);
     IO.enumCase(Value, "true", FormatStyle::BOS_All);
     IO.enumCase(Value, "None", FormatStyle::BOS_None);
     IO.enumCase(Value, "false", FormatStyle::BOS_None);
     IO.enumCase(Value, "NonAssignment", FormatStyle::BOS_NonAssignment);
   }
if (Style.AlwaysBreakAfterDefinitionReturnType != FormatStyle::DRTBS_None &&
             FormatStyle::RTBS_TopLevelDefinitions;
     }
 
     IO.mapOptional("AlwaysBreakBeforeMultilineStrings",
                    Style.AlwaysBreakBeforeMultilineStrings);
     IO.mapOptional("AlwaysBreakTemplateDeclarations",
                    Style.AlwaysBreakTemplateDeclarations);
     IO.mapOptional("AttributeMacros", Style.AttributeMacros);
+    IO.mapOptional("AutomaticBraces", Style.AutomaticBraces);
     IO.mapOptional("BinPackArguments", Style.BinPackArguments);
     IO.mapOptional("BinPackParameters", Style.BinPackParameters);
     IO.mapOptional("BraceWrapping", Style.BraceWrapping);
     IO.mapOptional("BreakBeforeBinaryOperators",
                    Style.BreakBeforeBinaryOperators);
     IO.mapOptional("BreakBeforeConceptDeclarations",
                    Style.BreakBeforeConceptDeclarations);
     IO.mapOptional("BreakBeforeBraces", Style.BreakBeforeBraces);
static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("BreakAfterJavaFieldAnnotations",
                    Style.BreakAfterJavaFieldAnnotations);
     IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
     IO.mapOptional("ColumnLimit", Style.ColumnLimit);
     IO.mapOptional("CommentPragmas", Style.CommentPragmas);
     IO.mapOptional("QualifierAlignment", Style.QualifierAlignment);
 
     // Default Order for Left/Right based Qualifier alignment.
-    if (Style.QualifierAlignment == FormatStyle::QAS_Right) {
+    if (Style.QualifierAlignment == FormatStyle::QAS_Right)
       Style.QualifierOrder = {"type", "const", "volatile"};
-    } else if (Style.QualifierAlignment == FormatStyle::QAS_Left) {
+    else if (Style.QualifierAlignment == FormatStyle::QAS_Left)
       Style.QualifierOrder = {"const", "volatile", "type"};
-    } else if (Style.QualifierAlignment == FormatStyle::QAS_Custom) {
+    else if (Style.QualifierAlignment == FormatStyle::QAS_Custom)
       IO.mapOptional("QualifierOrder", Style.QualifierOrder);
-    }
 
     IO.mapOptional("CompactNamespaces", Style.CompactNamespaces);
     IO.mapOptional("ConstructorInitializerIndentWidth",
                    Style.ConstructorInitializerIndentWidth);
     IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
     IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
     IO.mapOptional("DeriveLineEnding", Style.DeriveLineEnding);
     IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
const bool IsGoogleOrChromium = BasedOn.equals_insensitive("google") ||
                                     BasedOn.equals_insensitive("chromium");
     bool OnCurrentLine = IsGoogleOrChromium;
     bool OnNextLine = true;
     IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
                    OnCurrentLine);
     IO.mapOptional("AllowAllConstructorInitializersOnNextLine", OnNextLine);
     if (!IsGoogleOrChromium) {
       if (Style.PackConstructorInitializers == FormatStyle::PCIS_BinPack &&
-          OnCurrentLine) {
+          OnCurrentLine)
         Style.PackConstructorInitializers = OnNextLine
                                                 ? FormatStyle::PCIS_NextLine
                                                 : FormatStyle::PCIS_CurrentLine;
-      }
     } else if (Style.PackConstructorInitializers ==
                FormatStyle::PCIS_NextLine) {
       if (!OnCurrentLine)
         Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack;
       else if (!OnNextLine)
         Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine;
     }
 
static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("TypenameMacros", Style.TypenameMacros);
     IO.mapOptional("UseCRLF", Style.UseCRLF);
     IO.mapOptional("UseTab", Style.UseTab);
     IO.mapOptional("WhitespaceSensitiveMacros",
                    Style.WhitespaceSensitiveMacros);
   }
 };
 
+template <> struct MappingTraits<FormatStyle::AutomaticBracesOptions> {
+  static void mapping(IO &IO, FormatStyle::AutomaticBracesOptions &Style) {
+    IO.mapOptional("AfterIf", Style.AfterIf);
+    IO.mapOptional("AfterFor", Style.AfterFor);
+    IO.mapOptional("AfterWhile", Style.AfterWhile);
+    IO.mapOptional("AfterDo", Style.AfterDo);
+    IO.mapOptional("AfterElse", Style.AfterElse);
+    IO.mapOptional("BraceRemovalComments", Style.BraceRemovalComments);
+  }
+};
+
+template <>
+struct ScalarEnumerationTraits<FormatStyle::AutomaticBraceCommentAllowance> {
+  static void enumeration(IO &IO,
+                          FormatStyle::AutomaticBraceCommentAllowance &Value) {
+    IO.enumCase(Value, "None", FormatStyle::ABCA_Any);
+    IO.enumCase(Value, "Single", FormatStyle::ABCA_SingleLineOnly);
+    IO.enumCase(Value, "Multiple", FormatStyle::ABCA_MultipleLinesOnly);
+  }
+};
+
 template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
   static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
     IO.mapOptional("AfterCaseLabel", Wrapping.AfterCaseLabel);
     IO.mapOptional("AfterClass", Wrapping.AfterClass);
     IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
     IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
     IO.mapOptional("AfterFunction", Wrapping.AfterFunction);
     IO.mapOptional("AfterNamespace", Wrapping.AfterNamespace);

 template <> struct MappingTraits<FormatStyle::SpacesInLineComment> {
   static void mapping(IO &IO, FormatStyle::SpacesInLineComment &Space) {
     // Transform the maximum to signed, to parse "-1" correctly
     int signedMaximum = static_cast<int>(Space.Maximum);
     IO.mapOptional("Minimum", Space.Minimum);
     IO.mapOptional("Maximum", signedMaximum);
     Space.Maximum = static_cast<unsigned>(signedMaximum);
 
-    if (Space.Maximum != -1u) {
+    if (Space.Maximum != -1u)
       Space.Minimum = std::min(Space.Minimum, Space.Maximum);
-    }
-  }
 };
 
 // Allows to read vector<FormatStyle> while keeping default values.
 // IO.getContext() should contain a pointer to the FormatStyle structure, that
 // will be used to get default values for missing keys.
 // If the first element has no Language specified, it will be treated as the
 // default one for the following elements.
 template <> struct DocumentListTraits<std::vector<FormatStyle>> {
   static size_t size(IO &IO, std::vector<FormatStyle> &Seq) {
     return Seq.size();
   }
   static FormatStyle &element(IO &IO, std::vector<FormatStyle> &Seq,
                               size_t Index) {
     if (Index >= Seq.size()) {
       assert(Index == Seq.size());
       FormatStyle Template;
-      if (!Seq.empty() && Seq[0].Language == FormatStyle::LK_None) {
+      if (!Seq.empty() && Seq[0].Language == FormatStyle::LK_None)
         Template = Seq[0];
-      } else {
+      else {
         Template = *((const FormatStyle *)IO.getContext());
         Template.Language = FormatStyle::LK_None;
       }
       Seq.resize(Index + 1, Template);
     }
     return Seq[Index];
   }
 };
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.IndentAccessModifiers = false;
   LLVMStyle.IndentCaseLabels = false;
   LLVMStyle.IndentCaseBlocks = false;
   LLVMStyle.IndentGotoLabels = true;
   LLVMStyle.IndentPPDirectives = FormatStyle::PPDIS_None;
   LLVMStyle.IndentRequires = false;
   LLVMStyle.IndentWrappedFunctionNames = false;
   LLVMStyle.IndentWidth = 2;
+  LLVMStyle.AutomaticBraces = {/*AfterIf=*/FormatStyle::BIS_Leave,
+                               /*AfterFor=*/FormatStyle::BIS_Leave,
+                               /*AfterWhile=*/FormatStyle::BIS_Leave,
+                               /*AfterDo=*/FormatStyle::BIS_Leave,
+                               /*AfterElse=*/FormatStyle::BIS_Leave,
+                               /*BraceRemovalComments*/ FormatStyle::ABCA_Any};
+
   LLVMStyle.PPIndentWidth = -1;
   LLVMStyle.InsertTrailingCommas = FormatStyle::TCS_None;
   LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
   LLVMStyle.JavaScriptWrapImports = true;
   LLVMStyle.TabWidth = 8;
   LLVMStyle.LambdaBodyIndentation = FormatStyle::LBI_Signature;
   LLVMStyle.MaxEmptyLinesToKeep = 1;
   LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.StatementMacros.push_back("QT_REQUIRE_VERSION");
   LLVMStyle.WhitespaceSensitiveMacros.push_back("STRINGIZE");
   LLVMStyle.WhitespaceSensitiveMacros.push_back("PP_STRINGIZE");
   LLVMStyle.WhitespaceSensitiveMacros.push_back("BOOST_PP_STRINGIZE");
   LLVMStyle.WhitespaceSensitiveMacros.push_back("NS_SWIFT_NAME");
   LLVMStyle.WhitespaceSensitiveMacros.push_back("CF_SWIFT_NAME");
 
   // Defaults that differ when not C++.
-  if (Language == FormatStyle::LK_TableGen) {
+  if (Language == FormatStyle::LK_TableGen)
     LLVMStyle.SpacesInContainerLiterals = false;
-  }
-  if (LLVMStyle.isJson()) {
+  if (LLVMStyle.isJson())
     LLVMStyle.ColumnLimit = 0;
-  }
 
   return LLVMStyle;
 }
 
 FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
   if (Language == FormatStyle::LK_TextProto) {
     FormatStyle GoogleStyle = getGoogleStyle(FormatStyle::LK_Proto);
     GoogleStyle.Language = FormatStyle::LK_TextProto;
FormatStyle getNoStyle() {
   NoStyle.DisableFormat = true;
   NoStyle.SortIncludes = FormatStyle::SI_Never;
   NoStyle.SortUsingDeclarations = false;
   return NoStyle;
 }
 
 bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
                         FormatStyle *Style) {
-  if (Name.equals_insensitive("llvm")) {
+  if (Name.equals_insensitive("llvm"))
     *Style = getLLVMStyle(Language);
-  } else if (Name.equals_insensitive("chromium")) {
+  else if (Name.equals_insensitive("chromium"))
     *Style = getChromiumStyle(Language);
-  } else if (Name.equals_insensitive("mozilla")) {
+  else if (Name.equals_insensitive("mozilla"))
     *Style = getMozillaStyle();
-  } else if (Name.equals_insensitive("google")) {
+  else if (Name.equals_insensitive("google"))
     *Style = getGoogleStyle(Language);
-  } else if (Name.equals_insensitive("webkit")) {
+  else if (Name.equals_insensitive("webkit"))
     *Style = getWebKitStyle();
-  } else if (Name.equals_insensitive("gnu")) {
+  else if (Name.equals_insensitive("gnu"))
     *Style = getGNUStyle();
-  } else if (Name.equals_insensitive("microsoft")) {
+  else if (Name.equals_insensitive("microsoft"))
     *Style = getMicrosoftStyle(Language);
-  } else if (Name.equals_insensitive("none")) {
+  else if (Name.equals_insensitive("none"))
     *Style = getNoStyle();
-  } else if (Name.equals_insensitive("inheritparentconfig")) {
+  else if (Name.equals_insensitive("inheritparentconfig"))
     Style->InheritsParentConfig = true;
-  } else {
+  else
     return false;
-  }
 
   Style->Language = Language;
   return true;
 }
 
 ParseError validateQualifierOrder(FormatStyle *Style) {
   // If its empty then it means don't do anything.
   if (Style->QualifierOrder.empty())
public:
 
   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) {
+    for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i)
       Annotator.calculateFormattingInformation(*AnnotatedLines[i]);
-    }
     Annotator.setCommentLineLevels(AnnotatedLines);
 
     WhitespaceManager Whitespaces(
         Env.getSourceManager(), Style,
         Style.DeriveLineEnding
             ? inputUsesCRLF(
                   Env.getSourceManager().getBufferData(Env.getFileID()),
                   Style.UseCRLF)
TrailingCommaInserter(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;
     insertTrailingCommas(AnnotatedLines, Result);
     return {Result, 0};
   }
 
 private:
   /// Inserts trailing commas in [] and {} initializers if they wrap over
   /// multiple lines.
   void insertTrailingCommas(SmallVectorImpl<AnnotatedLine *> &Lines,
                             tooling::Replacements &Result) {
     for (AnnotatedLine *Line : Lines) {
       insertTrailingCommas(Line->Children, Result);
       if (!Line->Affected)
         continue;
       for (FormatToken *FormatTok = Line->First; FormatTok;
            FormatTok = FormatTok->Next) {
         if (FormatTok->NewlinesBefore == 0)
           continue;
         FormatToken *Matching = FormatTok->MatchingParen;
         if (!Matching || !FormatTok->getPreviousNonComment())
           continue;
         if (!(FormatTok->is(tok::r_square) &&
               Matching->is(TT_ArrayInitializerLSquare)) &&
             !(FormatTok->is(tok::r_brace) && Matching->is(TT_DictLiteral)))
analyze(TokenAnnotator &Annotator,
     for (auto *Line : AnnotatedLines)
       cleanupLine(Line);
 
     return {generateFixes(), 0};
   }
 
 private:
   void cleanupLine(AnnotatedLine *Line) {
-    for (auto *Child : Line->Children) {
+    for (auto *Child : Line->Children)
       cleanupLine(Child);
-    }
 
     if (Line->Affected) {
       cleanupRight(Line->First, tok::comma, tok::comma);
       cleanupRight(Line->First, TT_CtorInitializerColon, tok::comma);
       cleanupRight(Line->First, tok::l_paren, tok::comma);
       cleanupLeft(Line->First, tok::comma, tok::r_paren);
       cleanupLeft(Line->First, TT_CtorInitializerComma, tok::l_brace);
       cleanupLeft(Line->First, TT_CtorInitializerColon, tok::l_brace);
bool containsOnlyComments(const AnnotatedLine &Line) {
     return true;
   }
 
   // Iterate through all lines and remove any empty (nested) namespaces.
   void checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
     std::set<unsigned> DeletedLines;
     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
       auto &Line = *AnnotatedLines[i];
-      if (Line.startsWithNamespace()) {
+      if (Line.startsWithNamespace())
         checkEmptyNamespace(AnnotatedLines, i, i, DeletedLines);
-      }
-    }
 
     for (auto Line : DeletedLines) {
       FormatToken *Tok = AnnotatedLines[Line]->First;
       while (Tok) {
         deleteToken(Tok);
         Tok = Tok->Next;
       }
     }
bool checkEmptyNamespace(SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
     if (Style.BraceWrapping.AfterNamespace) {
       // If the left brace is in a new line, we should consume it first so that
       // it does not make the namespace non-empty.
       // FIXME: error handling if there is no left brace.
       if (!AnnotatedLines[++CurrentLine]->startsWith(tok::l_brace)) {
         NewLine = CurrentLine;
         return false;
       }
-    } else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace)) {
+    } else if (!AnnotatedLines[CurrentLine]->endsWith(tok::l_brace))
       return false;
-    }
     while (++CurrentLine < End) {
       if (AnnotatedLines[CurrentLine]->startsWith(tok::r_brace))
         break;
 
       if (AnnotatedLines[CurrentLine]->startsWithNamespace()) {
         if (!checkEmptyNamespace(AnnotatedLines, CurrentLine, NewLine,
                                  DeletedLines))
           return false;
if (CurrentLine >= End)
       return false;
 
     // Check if the empty namespace is actually affected by changed ranges.
     if (!AffectedRangeMgr.affectsCharSourceRange(CharSourceRange::getCharRange(
             AnnotatedLines[InitLine]->First->Tok.getLocation(),
             AnnotatedLines[CurrentLine]->Last->Tok.getEndLoc())))
       return false;
 
-    for (unsigned i = InitLine; i <= CurrentLine; ++i) {
+    for (unsigned i = InitLine; i <= CurrentLine; ++i)
       DeletedLines.insert(i);
-    }
 
     return true;
   }
 
   // Checks pairs {start, start->next},..., {end->previous, end} and deletes one
   // of the token in the pair if the left token has \p LK token kind and the
   // right token has \p RK token kind. If \p DeleteLeft is true, the left token
   // is deleted on match; otherwise, the right token is deleted.
tooling::Replacements generateFixes() {
 
     // Merge multiple continuous token deletions into one big deletion so that
     // the number of replacements can be reduced. This makes computing affected
     // ranges more efficient when we run reformat on the changed code.
     unsigned Idx = 0;
     while (Idx < Tokens.size()) {
       unsigned St = Idx, End = Idx;
       while ((End + 1) < Tokens.size() &&
-             Tokens[End]->Next == Tokens[End + 1]) {
+             Tokens[End]->Next == Tokens[End + 1])
         End++;
-      }
       auto SR = CharSourceRange::getCharRange(Tokens[St]->Tok.getLocation(),
                                               Tokens[End]->Tok.getEndLoc());
       auto Err =
           Fixes.add(tooling::Replacement(Env.getSourceManager(), SR, ""));
       // FIXME: better error handling. for now just print error message and skip
       // for the release version.
       if (Err) {
         llvm::errs() << llvm::toString(std::move(Err)) << "\n";
static void sortCppIncludes(const FormatStyle &Style,
   tooling::IncludeCategoryManager Categories(Style.IncludeStyle, FileName);
   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) {
+  for (unsigned i = 0, e = Includes.size(); i != e; ++i)
     Indices.push_back(i);
-  }
 
-  if (Style.SortIncludes == FormatStyle::SI_CaseInsensitive) {
+  if (Style.SortIncludes == FormatStyle::SI_CaseInsensitive)
     llvm::stable_sort(Indices, [&](unsigned LHSI, unsigned RHSI) {
       const auto LHSFilenameLower = Includes[LHSI].Filename.lower();
       const auto RHSFilenameLower = Includes[RHSI].Filename.lower();
       return std::tie(Includes[LHSI].Priority, LHSFilenameLower,
                       Includes[LHSI].Filename) <
              std::tie(Includes[RHSI].Priority, RHSFilenameLower,
                       Includes[RHSI].Filename);
     });
-  } else {
+  else
     llvm::stable_sort(Indices, [&](unsigned LHSI, unsigned RHSI) {
       return std::tie(Includes[LHSI].Priority, Includes[LHSI].Filename) <
              std::tie(Includes[RHSI].Priority, Includes[RHSI].Filename);
     });
-  }
 
   // The index of the include on which the cursor will be put after
   // sorting/deduplicating.
   unsigned CursorIndex;
   // The offset from cursor to the end of line.
   unsigned CursorToEOLOffset;
   if (Cursor)
     std::tie(CursorIndex, CursorToEOLOffset) =
for (;;) {
     }
     if (Pos == StringRef::npos || Pos + 1 == Code.size())
       break;
 
     if (!MergeWithNextLine)
       Prev = Pos + 1;
     SearchFrom = Pos + 1;
   }
-  if (!IncludesInBlock.empty()) {
+  if (!IncludesInBlock.empty())
     sortCppIncludes(Style, IncludesInBlock, Ranges, FileName, Code, Replaces,
                     Cursor);
-  }
   return Replaces;
 }
 
 // Returns group number to use as a first order sort on imports. Gives UINT_MAX
 // if the import does not match any given groups.
 static unsigned findJavaImportGroup(const FormatStyle &Style,
                                     StringRef ImportIdentifier) {
   unsigned LongestMatchIndex = UINT_MAX;
if (ImportRegex.match(Line, &Matches)) {
       if (FormattingOff) {
         // If at least one import line has formatting turned off, turn off
         // formatting entirely.
         return Replaces;
       }
       StringRef Static = Matches[1];
       StringRef Identifier = Matches[2];
       bool IsStatic = false;
-      if (Static.contains("static")) {
+      if (Static.contains("static"))
         IsStatic = true;
-      }
       ImportsInBlock.push_back(
           {Identifier, Line, Prev, AssociatedCommentLines, IsStatic});
       AssociatedCommentLines.clear();
     } else if (Trimmed.size() > 0 && !ImportsInBlock.empty()) {
       // Associating comments within the imports with the nearest import below
       AssociatedCommentLines.push_back(Line);
     }
     Prev = Pos + 1;
fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
   tooling::Replacements HeaderInsertions;
   std::set<llvm::StringRef> HeadersToDelete;
   tooling::Replacements Result;
   for (const auto &R : Replaces) {
     if (isHeaderInsertion(R)) {
       // Replacements from \p Replaces must be conflict-free already, so we can
       // simply consume the error.
       llvm::consumeError(HeaderInsertions.add(R));
-    } else if (isHeaderDeletion(R)) {
+    } else if (isHeaderDeletion(R))
       HeadersToDelete.insert(R.getReplacementText());
-    } else if (R.getOffset() == UINT_MAX) {
+    else if (R.getOffset() == UINT_MAX)
       llvm::errs() << "Insertions other than header #include insertion are "
                       "not supported! "
                    << R.getReplacementText() << "\n";
-    } else {
+    else
       llvm::consumeError(Result.add(R));
-    }
-  }
   if (HeaderInsertions.empty() && HeadersToDelete.empty())
     return Replaces;
 
   StringRef FileName = Replaces.begin()->getFilePath();
   tooling::HeaderIncludes Includes(FileName, Code, Style.IncludeStyle);
 
   for (const auto &Header : HeadersToDelete) {
     tooling::Replacements Replaces =
auto Env =
         std::make_unique<Environment>(Code, FileName, Ranges, FirstStartColumn,
                                       NextStartColumn, LastStartColumn);
     // Perform the actual formatting pass.
     tooling::Replacements Replaces =
         Formatter(*Env, Style, Status).process().first;
     // add a replacement to remove the "x = " from the result.
     if (!Replaces.add(tooling::Replacement(FileName, 0, 4, ""))) {
       // apply the reformatting changes and the removal of "x = ".
-      if (applyAllReplacements(Code, Replaces)) {
+      if (applyAllReplacements(Code, Replaces))
         return {Replaces, 0};
-      }
-    }
     return {tooling::Replacements(), 0};
   }
 
   typedef std::function<std::pair<tooling::Replacements, unsigned>(
       const Environment &)>
       AnalyzerPass;
   SmallVector<AnalyzerPass, 4> Passes;
 
-  if (Style.isCpp() && Style.QualifierAlignment != FormatStyle::QAS_Leave) {
+  if (Style.isCpp() && Style.QualifierAlignment != FormatStyle::QAS_Leave)
     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.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();
       });
   }
 
+  Passes.emplace_back([&](const Environment &Env) {
+    return AutomaticBraces(Env, Expanded).process();
+  });
+
   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();

 const char *DefaultFormatStyle = "file";
 
 const char *DefaultFallbackStyle = "LLVM";
 
 llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
                                      StringRef FallbackStyleName,
                                      StringRef Code, llvm::vfs::FileSystem *FS,
                                      bool AllowUnknownOptions) {
-  if (!FS) {
+  if (!FS)
     FS = llvm::vfs::getRealFileSystem().get();
-  }
   FormatStyle Style = getLLVMStyle(guessLanguage(FileName, Code));
 
   FormatStyle FallbackStyle = getNoStyle();
   if (!getPredefinedStyle(FallbackStyleName, Style.Language, &FallbackStyle))
     return make_string_error("Invalid fallback style \"" + FallbackStyleName);
 
   llvm::SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 1>
       ChildFormatTextToApply;
llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
 
   auto dropDiagnosticHandler = [](const llvm::SMDiagnostic &, void *) {};
 
   for (StringRef Directory = Path; !Directory.empty();
        Directory = llvm::sys::path::parent_path(Directory)) {
 
     auto Status = FS->status(Directory);
     if (!Status ||
-        Status->getType() != llvm::sys::fs::file_type::directory_file) {
+        Status->getType() != llvm::sys::fs::file_type::directory_file)
       continue;
-    }
 
     for (const auto &F : FilesToLookFor) {
       SmallString<128> ConfigFile(Directory);
 
       llvm::sys::path::append(ConfigFile, F);
       LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
 
       Status = FS->status(ConfigFile.str());

clang/unittests/Format/AutomaticBracesTest.cpp

+//===- unittest/Format/AutomaticBracesTest.cpp - brace insertion unit tests
+//-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Format/Format.h"
+
+#include "../Tooling/ReplacementTest.h"
+#include "FormatTestUtils.h"
+
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "gtest/gtest.h"
+
+#define DEBUG_TYPE "automatic-braces-test"
+
+using clang::tooling::ReplacementTest;
+using clang::tooling::toReplacements;
+using testing::ScopedTrace;
+
+namespace clang {
+namespace format {
+namespace {
+
+class AutomaticBracesTest : 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) {
+    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);
+    if (CheckComplete != SC_DoNotCheck) {
+      bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete;
+      EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
+          << Code << "\n\n";
+    }
+    auto Result = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE(static_cast<bool>(Result));
+    LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
+    return *Result;
+  }
+
+  FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) {
+    Style.ColumnLimit = ColumnLimit;
+    return Style;
+  }
+
+  FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
+    return getStyleWithColumns(getLLVMStyle(), ColumnLimit);
+  }
+
+  void _verifyFormat(const char *File, int Line, llvm::StringRef Expected,
+                     llvm::StringRef Code,
+                     const FormatStyle &Style = getLLVMStyle()) {
+    ScopedTrace t(File, Line, ::testing::Message() << Code.str());
+    EXPECT_EQ(Expected.str(), format(Expected, Style))
+        << "Expected code is not stable";
+    EXPECT_EQ(Expected.str(), format(Code, Style));
+  }
+
+  void _verifyFormat(const char *File, int Line, llvm::StringRef Code,
+                     const FormatStyle &Style = getLLVMStyle()) {
+    _verifyFormat(File, Line, Code, test::messUp(Code), Style);
+  }
+};
+
+#define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__)
+
+TEST_F(AutomaticBracesTest, InsertBraces) {
+  FormatStyle Style = getLLVMStyle();
+
+  StringRef IfSourceShort = "if (condition)\n"
+                            "  call_function(arg, arg);";
+  verifyFormat(IfSourceShort);
+
+  StringRef IfSourceLong = "if (condition)\n"
+                           "  call_function(arg, arg, arg, arg, arg, arg);";
+  verifyFormat(IfSourceLong);
+
+  StringRef IfElseSourceShort = "if (condition)\n"
+                                "  a_function(arg, arg);\n"
+                                "else\n"
+                                "  another_function(arg, arg);";
+  verifyFormat(IfElseSourceShort);
+
+  StringRef IfElseSourceLong =
+      "if (condition)\n"
+      "  a_function(arg, arg, arg, arg, arg, arg);\n"
+      "else\n"
+      "  another_function(arg, arg, arg, arg, arg, arg);";
+  verifyFormat(IfElseSourceLong);
+
+  StringRef ForSourceShort = "for (auto val : container)\n"
+                             "  call_function(arg, arg);";
+  verifyFormat(ForSourceShort);
+
+  StringRef ForSourceLong = "for (auto val : container)\n"
+                            "  call_function(arg, arg, arg, arg, arg, arg);";
+  verifyFormat(ForSourceLong);
+
+  StringRef WhileShort = "while (condition)\n"
+                         "  call_function(arg, arg);";
+  verifyFormat(WhileShort);
+
+  StringRef WhileLong = "while (condition)\n"
+                        "  call_function(arg, arg, arg, arg, arg, arg);";
+  verifyFormat(WhileLong);
+
+  StringRef DoShort = "do\n"
+                      "  call_function(arg, arg);\n"
+                      "while (condition);";
+  verifyFormat(DoShort);
+
+  StringRef DoLong = "do\n"
+                     "  call_function(arg, arg, arg, arg, arg, arg);\n"
+                     "while (condition);";
+  verifyFormat(DoLong);
+
+  StringRef ChainedConditionals = "if (A)\n"
+                                  "  if (B)\n"
+                                  "    callAB();\n"
+                                  "  else\n"
+                                  "    callA();\n"
+                                  "else if (B)\n"
+                                  "  callB();\n"
+                                  "else\n"
+                                  "  call();";
+  verifyFormat(ChainedConditionals);
+
+  StringRef ChainedDoWhiles = "do\n"
+                              "  while (arg++)\n"
+                              "    do\n"
+                              "      while (arg++)\n"
+                              "        call_function(arg, arg);\n"
+                              "    while (condition);\n"
+                              "while (condition);";
+  verifyFormat(ChainedDoWhiles);
+
+  StringRef IfWithMultilineComment =
+      "if /*condition*/ (condition) /*condition*/\n"
+      "  you_do_you();              /*condition*/";
+  verifyFormat(IfWithMultilineComment);
+
+  StringRef IfSinglelineCommentOnConditional = "if (condition) // my test\n"
+                                               "  you_do_you();";
+  verifyFormat(IfSinglelineCommentOnConditional);
+
+  Style.AutomaticBraces.AfterIf = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterFor = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterWhile = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterDo = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterElse = FormatStyle::BIS_Always;
+
+  verifyFormat("while (condition) {\n"
+               "  call_function(arg, arg);\n"
+               "}",
+               WhileShort, Style);
+
+  verifyFormat("while (condition) {\n"
+               "  call_function(arg, arg, arg, arg, arg, arg);\n"
+               "}",
+               WhileLong, Style);
+
+  verifyFormat("do {\n"
+               "  call_function(arg, arg);\n"
+               "} while (condition);",
+               DoShort, Style);
+
+  verifyFormat("do {\n"
+               "  call_function(arg, arg, arg, arg, arg, arg);\n"
+               "} while (condition);",
+               DoLong, Style);
+
+  verifyFormat("if (condition) {\n"
+               "  call_function(arg, arg);\n"
+               "}",
+               IfSourceShort, Style);
+
+  verifyFormat("if (condition) {\n"
+               "  call_function(arg, arg);\n"
+               "}",
+               IfSourceShort, Style);
+
+  verifyFormat("if (condition) {\n"
+               "  call_function(arg, arg, arg, arg, arg, arg);\n"
+               "}",
+               IfSourceLong, Style);
+
+  verifyFormat("if (condition) {\n"
+               "  a_function(arg, arg);\n"
+               "} else {\n"
+               "  another_function(arg, arg);\n"
+               "}",
+               IfElseSourceShort, Style);
+
+  verifyFormat("if (condition) {\n"
+               "  a_function(arg, arg, arg, arg, arg, arg);\n"
+               "} else {\n"
+               "  another_function(arg, arg, arg, arg, arg, arg);\n"
+               "}",
+               IfElseSourceLong, Style);
+
+  verifyFormat("for (auto val : container) {\n"
+               "  call_function(arg, arg);\n"
+               "}",
+               ForSourceShort, Style);
+
+  verifyFormat("for (auto val : container) {\n"
+               "  call_function(arg, arg, arg, arg, arg, arg);\n"
+               "}",
+               ForSourceLong, Style);
+
+  verifyFormat("if (A)\n"
+               "  if (B) {\n"
+               "    callAB();\n"
+               "  } else {\n"
+               "    callA();\n"
+               "  }\n"
+               "else if (B) {\n"
+               "  callB();\n"
+               "} else {\n"
+               "  call();\n"
+               "}",
+               ChainedConditionals, Style);
+
+  verifyFormat("do\n"
+               "  while (arg++)\n"
+               "    do\n"
+               "      while (arg++) {\n"
+               "        call_function(arg, arg);\n"
+               "      }\n"
+               "    while (condition);\n"
+               "while (condition);",
+               ChainedDoWhiles, Style);
+
+  verifyFormat("if /*condition*/ (condition) /*condition*/\n"
+               "{\n"
+               "  you_do_you(); /*condition*/\n"
+               "}",
+               IfWithMultilineComment, Style);
+
+  verifyFormat("if (condition) // my test\n"
+               "{\n"
+               "  you_do_you();\n"
+               "}",
+               IfSinglelineCommentOnConditional, Style);
+
+  Style.AutomaticBraces.AfterIf = FormatStyle::BIS_WrapLikely;
+  Style.AutomaticBraces.AfterFor = FormatStyle::BIS_WrapLikely;
+  Style.AutomaticBraces.AfterWhile = FormatStyle::BIS_WrapLikely;
+  Style.AutomaticBraces.AfterDo = FormatStyle::BIS_WrapLikely;
+  Style.AutomaticBraces.AfterElse = FormatStyle::BIS_WrapLikely;
+  Style.ColumnLimit = 35;
+
+  verifyFormat(IfSourceShort, IfSourceShort, Style);
+
+  verifyFormat("if (condition) {\n"
+               "  call_function(arg, arg, arg, arg,\n"
+               "                arg, arg);\n"
+               "}",
+               IfSourceLong, Style);
+
+  verifyFormat(IfElseSourceShort, IfElseSourceShort, Style);
+
+  verifyFormat("if (condition) {\n"
+               "  a_function(arg, arg, arg, arg,\n"
+               "             arg, arg);\n"
+               "} else {\n"
+               "  another_function(arg, arg, arg,\n"
+               "                   arg, arg, arg);\n"
+               "}",
+               IfElseSourceLong, Style);
+
+  verifyFormat(ForSourceShort, ForSourceShort, Style);
+
+  verifyFormat("for (auto val : container) {\n"
+               "  call_function(arg, arg, arg, arg,\n"
+               "                arg, arg);\n"
+               "}",
+               ForSourceLong, Style);
+
+  format("while (foo) ", Style);
+}
+
+TEST_F(AutomaticBracesTest, InsertBracesMacro) {
+  auto Style = getLLVMStyleWithColumns(20);
+
+  verifyFormat("#define FOO1(x)    \\\n"
+               "  if (x)           \\\n"
+               "    return true;   \\\n"
+               "  else             \\\n"
+               "    return false;",
+               Style);
+
+  Style.AutomaticBraces.AfterIf = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterFor = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterWhile = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterDo = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterElse = FormatStyle::BIS_Always;
+
+  verifyFormat("#define FOO2(x)    \\\n"
+               "  if (x) {         \\\n"
+               "    return true;   \\\n"
+               "  } else {         \\\n"
+               "    return false;  \\\n"
+               "  }",
+               "#define FOO2(x)    \\\n"
+               "  if (x)           \\\n"
+               "    return true;   \\\n"
+               "  else             \\\n"
+               "    return false;",
+               Style);
+
+  verifyFormat("#define FOO3(x)    \\\n"
+               "  if (x) {         \\\n"
+               "    return true;   \\\n"
+               "  } else {         \\\n"
+               "    return false;  \\\n"
+               "  }",
+               Style);
+}
+
+TEST_F(AutomaticBracesTest, InsertBracesComments) {
+  auto Style = getLLVMStyle();
+
+  verifyFormat("if (x)\n"
+               "  return true;\n"
+               "else\n"
+               "  return false;",
+               Style);
+
+  Style.AutomaticBraces.AfterIf = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterFor = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterWhile = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterDo = FormatStyle::BIS_Always;
+  Style.AutomaticBraces.AfterElse = FormatStyle::BIS_Always;
+
+  verifyFormat("if (x) {\n"
+               "  return true; // Comment\n"
+               "} else {\n"
+               "  return false; // Comment\n"
+               "}",
+               "if (x)\n"
+               "  return true; // Comment\n"
+               "else\n"
+               "  return false; // Comment",
+               Style);
+}
+
+TEST_F(AutomaticBracesTest, RemoveBraces) {
+  auto Style = getLLVMStyle();
+
+  Style.AutomaticBraces.AfterIf = FormatStyle::BIS_Remove;
+  Style.AutomaticBraces.AfterFor = FormatStyle::BIS_Remove;
+  Style.AutomaticBraces.AfterWhile = FormatStyle::BIS_Remove;
+  Style.AutomaticBraces.AfterDo = FormatStyle::BIS_Remove;
+  Style.AutomaticBraces.AfterElse = FormatStyle::BIS_Remove;
+
+  verifyFormat("if (x)\n"
+               "  return true;\n",
+               "if (x) {\n"
+               "  return true;\n"
+               "}",
+               Style);
+
+  verifyFormat("while (x)\n"
+               "  foo();\n",
+               "while (x) {\n"
+               "  foo();\n"
+               "}",
+               Style);
+
+  verifyFormat("if (x)\n"
+               "  return true;\n"
+               "else\n"
+               "  return false;\n",
+               "if (x) {\n"
+               "  return true;\n"
+               "} else {\n"
+               "  return false;\n"
+               "}\n",
+               Style);
+
+  verifyFormat("if (x)\n"
+               "  return true;\n"
+               "else if (x == 1)\n"
+               "  return false;\n",
+               "if (x) {\n"
+               "  return true;\n"
+               "} else if (x == 1) {\n"
+               "  return false;\n"
+               "}\n",
+               Style);
+
+  verifyFormat("if (x) {\n"
+               "  foo();\n"
+               "  bar();\n"
+               "} else if (x == 1)\n"
+               "  return false;\n",
+               "if (x) {\n"
+               "  foo();\n"
+               "  bar();\n"
+               "} else if (x == 1) {\n"
+               "  return false;\n"
+               "}\n",
+               Style);
+
+  verifyFormat("if (x)\n"
+               "  foo();\n"
+               "else if (x == 1) {\n"
+               "  baz();\n"
+               "  bar();\n"
+               "}\n",
+               "if (x) {\n"
+               "  foo();\n"
+               "} else if (x == 1) {\n"
+               "  baz();\n"
+               "  bar();\n"
+               "}\n",
+               Style);
+
+  verifyFormat("if (x) {\n"
+               "  if (y)\n"
+               "    foo();\n"
+               "} else {\n"
+               "  baz();\n"
+               "  bar();\n"
+               "}\n",
+               Style);
+
+  verifyFormat("if (a)\n"
+               "  b;\n"
+               "else if (c)\n"
+               "  d;\n"
+               "else\n"
+               "  e;\n",
+               "if (a) {\n"
+               "  b;\n"
+               "} else if (c) {\n"
+               "  d;\n"
+               "} else {\n"
+               "  e;\n"
+               "}\n",
+               Style);
+
+  verifyFormat("if (a) {\n"
+               "  if (b)\n"
+               "    c;\n"
+               "} else if (d)\n"
+               "  e;\n",
+               "if (a) {\n"
+               "  if (b) {\n"
+               "    c;\n"
+               "  }\n"
+               "} else if (d) {\n"
+               "  e;\n"
+               "}",
+               Style);
+}
+
+TEST_F(AutomaticBracesTest, RemoveLLVMBraces) {
+  auto Style = getLLVMStyle();
+
+  Style.AutomaticBraces.AfterIf = FormatStyle::BIS_Remove;
+  Style.AutomaticBraces.AfterElse = FormatStyle::BIS_Remove;
+  Style.AutomaticBraces.AfterFor = FormatStyle::BIS_Remove;
+  Style.AutomaticBraces.AfterDo = FormatStyle::BIS_Remove;
+  Style.AutomaticBraces.AfterWhile = FormatStyle::BIS_Remove;
+  Style.AutomaticBraces.BraceRemovalComments =
+      FormatStyle::AutomaticBraceCommentAllowance::ABCA_Any;
+
+  // Omit the braces, since the body is simple and clearly associated with the
+  // if.
+  verifyFormat("if (isa<FunctionDecl>(D))\n"
+               "  foo(D);\n"
+               "else if (isa<VarDecl>(D))\n"
+               "  bar(D);\n",
+               Style);
+
+  verifyFormat("if (isa<FunctionDecl>(D))\n"
+               "  handleFunctionDecl(D);\n"
+               "else if (isa<VarDecl>(D))\n"
+               "  handleVarDecl(D);\n",
+               "if (isa<FunctionDecl>(D)) {\n"
+               "  handleFunctionDecl(D);\n"
+               "} else if (isa<VarDecl>(D)) {\n"
+               "  handleVarDecl(D);\n"
+               "}",
+               Style);
+
+  verifyFormat("while (isa<FunctionDecl>(D))\n"
+               "  handleFunctionDecl(D);\n",
+               Style);
+
+  verifyFormat("while (isa<FunctionDecl>(D))\n"
+               "  handleFunctionDecl(D);\n",
+               "while (isa<FunctionDecl>(D)) {\n"
+               "  handleFunctionDecl(D);\n"
+               "}",
+               Style);
+
+  verifyFormat("while (isa<FunctionDecl>(D)) {\n"
+               "  // A single line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "}",
+               Style);
+
+  verifyFormat("do\n"
+               "  handleFunctionDecl(D);\n"
+               "while (true);",
+               Style);
+
+  verifyFormat("do\n"
+               "  handleFunctionDecl(D);\n"
+               "while (true);",
+               "do {\n"
+               "  handleFunctionDecl(D);\n"
+               "} while (true);",
+               Style);
+
+  verifyFormat("do {\n"
+               "  // A single line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "} while (true);",
+               Style);
+
+  verifyFormat("for (auto i : list)\n"
+               "  handleFunctionDecl(D);\n",
+               Style);
+
+  verifyFormat("for (auto i : list)\n"
+               "  handleFunctionDecl(D);\n",
+               "for(auto i : list) {\n"
+               "  handleFunctionDecl(D);\n"
+               "}",
+               Style);
+
+  verifyFormat("for (auto i : list) {\n"
+               "  // A single line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "}",
+               Style);
+
+  // 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 "
+      "surprisingly long\n"
+      "  // comment, so it would be unclear without the braces whether the "
+      "following\n"
+      "  // statement is in the scope of the `if`.\n"
+      "  // Because the condition is documented, we can't really hoist this\n"
+      "  // comment that applies to the body above the if.\n"
+      "  handleOtherDecl(D);\n"
+      "}",
+      Style);
+
+  // Use braces on the outer `if` to avoid a potential dangling else situation.
+  verifyFormat("if (isa<VarDecl>(D)) {\n"
+               "  for (auto *A : D.attrs())\n"
+               "    if (shouldProcessAttr(A))\n"
+               "      handleAttr(A);\n"
+               "}\n",
+               Style);
+  verifyFormat("if (isa<VarDecl>(D)) {\n"
+               "  for (auto *A : D.attrs()) {\n"
+               "    if (shouldProcessAttr(A))\n"
+               "      handleAttr(A);\n"
+               "  }\n"
+               "}\n",
+               "if (isa<VarDecl>(D)) {\n"
+               "  for (auto *A : D.attrs()) {\n"
+               "    if (shouldProcessAttr(A)) {\n"
+               "      handleAttr(A);\n"
+               "    }\n"
+               "  }\n"
+               "}\n",
+               Style);
+
+  // if the for or if have {} here should they be removed?
+  verifyFormat("if (isa<VarDecl>(D)) {\n"
+               "  for (auto *A : D.attrs())\n"
+               "    if (shouldProcessAttr(A))\n"
+               "      handleAttr(A);\n"
+               "}\n",
+               "if (isa<VarDecl>(D)) {\n"
+               "  for (auto *A : D.attrs())\n"
+               "    if (shouldProcessAttr(A))\n"
+               "      handleAttr(A);\n"
+               "}\n",
+               Style);
+
+  // 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 situation "
+      "with\n"
+      "  // this surprisingly long comment, so it would be unclear without the "
+      "braces\n"
+      "  // whether the following statement is in the scope of the `if`.\n"
+      "  handleOtherDecl(D);\n"
+      "}\n",
+      Style);
+
+  // 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.
+  verifyFormat("if (isa<FunctionDecl>(D))\n"
+               "  for (auto *A : D.attrs())\n"
+               "    handleAttr(A);\n",
+               Style);
+
+  verifyFormat("if (isa<FunctionDecl>(D))\n"
+               "  for (auto *A : D.attrs())\n"
+               "    handleAttr(A);\n",
+               "if (isa<FunctionDecl>(D)) {\n"
+               "  for (auto *A : D.attrs()) {\n"
+               "    handleAttr(A);\n"
+               "  }\n"
+               "}",
+               Style);
+
+  // 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 "
+               "the situation\n"
+               "    // with this surprisingly long comment, forcing braces on "
+               "the `for` block.\n"
+               "    handleAttr(A);\n"
+               "  }\n"
+               "}",
+               Style);
+
+  // Use braces on the outer block because there are more than two levels of
+  // nesting.
+  verifyFormat("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",
+               Style);
+
+  verifyFormat("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",
+               "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"
+               "}\n",
+               Style);
+
+  // Use braces on the outer block because of a nested `if`, otherwise the
+  // compiler would warn: `add explicit braces to avoid dangling else`
+  verifyFormat("if (auto *D = dyn_cast<FunctionDecl>(D)) {\n"
+               "  if (shouldProcess(D))\n"
+               "    handleVarDecl(D);\n"
+               "  else\n"
+               "    markAsIgnored(D);\n"
+               "}\n",
+               Style);
+
+  verifyFormat("if (auto *D = dyn_cast<FunctionDecl>(D)) {\n"
+               "  if (shouldProcess(D))\n"
+               "    handleVarDecl(D);\n"
+               "  else\n"
+               "    markAsIgnored(D);\n"
+               "}\n",
+               "if (auto *D = dyn_cast<FunctionDecl>(D)) {\n"
+               "  if (shouldProcess(D)) {\n"
+               "    handleVarDecl(D);\n"
+               "  } else {\n"
+               "    markAsIgnored(D);\n"
+               "  }\n"
+               "}\n",
+               Style);
+
+  Style.AutomaticBraces.BraceRemovalComments =
+      FormatStyle::AutomaticBraceCommentAllowance::ABCA_SingleLineOnly;
+  verifyFormat("if (isa<VarDecl>(D))\n"
+               "  // It is necessary that we explain the situation with this "
+               "surprisingly long\n"
+               "  handleOtherDecl(D);\n"
+               "}",
+               Style);
+
+  // Removing as {} evem though we have a comment comment
+  Style.AutomaticBraces.BraceRemovalComments =
+      FormatStyle::AutomaticBraceCommentAllowance::ABCA_MultipleLinesOnly;
+  verifyFormat(
+      "if (isa<VarDecl>(D))\n"
+      "  // It is necessary that we explain the situation with this "
+      "surprisingly long\n"
+      "  // comment, so it would be unclear without the braces whether the "
+      "following\n"
+      "  // statement is in the scope of the `if`.\n"
+      "  // Because the condition is documented, we can't really hoist this\n"
+      "  // comment that applies to the body above the if.\n"
+      "  handleOtherDecl(D);\n",
+      "if (isa<VarDecl>(D)) {\n"
+      "  // It is necessary that we explain the situation with this "
+      "surprisingly long\n"
+      "  // comment, so it would be unclear without the braces whether the "
+      "following\n"
+      "  // statement is in the scope of the `if`.\n"
+      "  // Because the condition is documented, we can't really hoist this\n"
+      "  // comment that applies to the body above the if.\n"
+      "  handleOtherDecl(D);\n"
+      "}",
+      Style);
+
+  Style.AutomaticBraces.BraceRemovalComments =
+      FormatStyle::AutomaticBraceCommentAllowance::ABCA_SingleLineOnly;
+  verifyFormat("do\n"
+               "  // A single line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "while (true);",
+               "do {\n"
+               "  // A single line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "} while (true);",
+               Style);
+
+  Style.AutomaticBraces.BraceRemovalComments =
+      FormatStyle::AutomaticBraceCommentAllowance::ABCA_MultipleLinesOnly;
+  verifyFormat("do\n"
+               "  // A multi line comment\n"
+               "  // A multi line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "while (true);",
+               "do {\n"
+               "  // A multi line comment\n"
+               "  // A multi line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "} while (true);",
+               Style);
+
+  Style.AutomaticBraces.BraceRemovalComments =
+      FormatStyle::AutomaticBraceCommentAllowance::ABCA_SingleLineOnly;
+
+  verifyFormat("while (isa<FunctionDecl>(D))\n"
+               "  // A single line comment\n"
+               "  handleFunctionDecl(D);\n",
+               "while (isa<FunctionDecl>(D)) {\n"
+               "  // A single line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "}",
+               Style);
+
+  Style.AutomaticBraces.BraceRemovalComments =
+      FormatStyle::AutomaticBraceCommentAllowance::ABCA_MultipleLinesOnly;
+
+  verifyFormat("while (isa<FunctionDecl>(D))\n"
+               "  // A multi line comment\n"
+               "  // A multi line comment\n"
+               "  handleFunctionDecl(D);\n",
+               "while (isa<FunctionDecl>(D)) {\n"
+               "  // A multi line comment\n"
+               "  // A multi line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "}",
+               Style);
+
+  Style.AutomaticBraces.BraceRemovalComments =
+      FormatStyle::AutomaticBraceCommentAllowance::ABCA_SingleLineOnly;
+
+  verifyFormat("for (auto i : list)\n"
+               "  // A single line comment\n"
+               "  handleFunctionDecl(D);\n",
+               "for (auto i : list) {\n"
+               "  // A single line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "}",
+               Style);
+
+  Style.AutomaticBraces.BraceRemovalComments =
+      FormatStyle::AutomaticBraceCommentAllowance::ABCA_MultipleLinesOnly;
+
+  verifyFormat("for (auto i : list)\n"
+               "  // A multi line comment\n"
+               "  // A multi line comment\n"
+               "  handleFunctionDecl(D);\n",
+               "for (auto i : list) {\n"
+               "  // A multi line comment\n"
+               "  // A multi line comment\n"
+               "  handleFunctionDecl(D);\n"
+               "}",
+               Style);
+}
+
+} // namespace
+} // namespace format
+} // namespace clang

clang/unittests/Format/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(FormatTests
+  AutomaticBracesTest.cpp
   CleanupTest.cpp
   FormatTest.cpp
   FormatTestComments.cpp
   FormatTestCSharp.cpp
   FormatTestJS.cpp
   FormatTestJava.cpp
   FormatTestJson.cpp
   FormatTestObjC.cpp

clang/unittests/Format/FormatTest.cpp

protected:
 
   void _verifyFormat(const char *File, int Line, llvm::StringRef Expected,
                      llvm::StringRef Code,
                      const FormatStyle &Style = getLLVMStyle()) {
     ScopedTrace t(File, Line, ::testing::Message() << Code.str());
     EXPECT_EQ(Expected.str(), format(Expected, Style))
         << "Expected code is not stable";
     EXPECT_EQ(Expected.str(), format(Code, Style));
+    // clang::format::internal::reformat does not run any of the options that
+    // modify code for ObjC
     if (Style.Language == FormatStyle::LK_Cpp) {
       // Objective-C++ is a superset of C++, so everything checked for C++
       // needs to be checked for Objective-C++ as well.
       FormatStyle ObjCStyle = Style;
       ObjCStyle.Language = FormatStyle::LK_ObjC;
       EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
     }
   }
 
   void _verifyFormat(const char *File, int Line, llvm::StringRef Code,
verifyFormat(
       getLLVMStyleWithColumns(65));
 
   // This test takes VERY long when memoization is broken.
   FormatStyle OnePerLine = getLLVMStyle();
   OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
   OnePerLine.BinPackParameters = false;
   std::string input = "Constructor()\n"
                       "    : aaaa(a,\n";
-  for (unsigned i = 0, e = 80; i != e; ++i) {
+  for (unsigned i = 0, e = 80; i != e; ++i)
     input += "           a,\n";
-  }
   input += "           a) {}";
   verifyFormat(input, OnePerLine);
 }
 #endif
 
 TEST_F(FormatTest, BreaksAsHighAsPossible) {
   verifyFormat(
       "void f() {\n"
EXPECT_EQ("void Foo::slot() {\n"
             "}",
             format(Source, Style));
 }
 
 TEST_F(FormatTest, IndentAccessModifiers) {
   FormatStyle Style = getLLVMStyle();
   Style.IndentAccessModifiers = true;
   // Members are *two* levels below the record;
   // Style.IndentWidth == 2, thus yielding a 4 spaces wide indentation.
   verifyFormat("class C {\n"
                "    int i;\n"
                "};\n",
                Style);
   verifyFormat("union C {\n"
                "    int i;\n"
                "    unsigned u;\n"
                "};\n",
                Style);
   // Access modifiers should be indented one level below the record.
   verifyFormat("class C {\n"
                "  public:\n"
                "    int i;\n"
                "};\n",
                Style);
   verifyFormat("struct S {\n"
                "  private:\n"
                "    class C {\n"
                "        int j;\n"
                "\n"
                "      public:\n"
                "        C();\n"
                "    };\n"
                "\n"
                "  public:\n"
constexpr StringRef Code =
       "  // We already did this with multi line comments and strings. Just to "
       "check if everything is working.\n"
       "  const std::string SmallString = \"Hello World\";\n"
       "  // Small line comment\n"
       "  return String.size() > SmallString.size();\n"
       "}";
   EXPECT_EQ(Code, format(Code, Style));
 }
-
 } // namespace
 } // namespace format
 } // namespace clang