[clang-format][NFC] Reformat clang/lib/Format using 6257832bf94f

[owenpan]

Summary

Fix braces and add .clang-format to keep the directory formatted.

[MyDeveloperDay]

LGTM, we of all people have to dogfood this stuff..

[sstwcw]

Did you leave out clang/include/clang/Format and clang/unittests/Format?

[owenpan]

In D134329#3805704, @sstwcw wrote:

Did you leave out clang/include/clang/Format and clang/unittests/Format?

I was going to take care of them after this patch. Thanks for asking though.

[owenpan]

In D134329#3806667, @owenpan wrote:

In D134329#3805704, @sstwcw wrote:

Did you leave out clang/include/clang/Format and clang/unittests/Format?

I was going to take care of them after this patch. Thanks for asking though.

See e347c0fc9bf8.

[MyDeveloperDay]

Unfortunately this is causing the failing the "premerge checks" on reviews likely because this machine is using an earlier version of clang-format

To be honest, I'd love to fix this by making this "unknown key" just a warning. For some keys we don't need them to be recognized (this is one, RemoveBracesLLVM is another)

[owenpan]

In D134329#3817601, @MyDeveloperDay wrote:

Unfortunately this is causing the failing the "premerge checks" on reviews likely because this machine is using an earlier version of clang-format

Isn't this the case for any new option? IMO anyone who updated the source to include a new option should build a new clang-format and use that for pre-merge checks.

[MyDeveloperDay]

I'm not sure what version of clang-format they use in the premerge checks, I don't know who we contact to get it updated. I guess the clang-format check might come before any building of the code.

You know if we relex the "Unknown" YAML option, this would go a long way not only to help us here but also to that situation where new options break people using older clang-format version.

[owenpan]

In D134329#3822028, @MyDeveloperDay wrote:

I guess the clang-format check might come before any building of the code.

+1.

You know if we relex the "Unknown" YAML option, this would go a long way not only to help us here but also to that situation where new options break people using older clang-format version.

Changing an unknown/misspelled-option error to a warning will also change the return code of clang-format. That would be unacceptable to a lot people, I believe.

In general, new options won't cause problems for people unless they add them to config files without updating clang-format. The situation with clang-format sources is very unique and rarely occurs, so it's probably better to just leave it as is.

[MyDeveloperDay]

yeah I'm ok with that too.

clang/lib/Format/.clang-format

+BasedOnStyle: LLVM
+InsertBraces: true
+RemoveBracesLLVM: true

clang/lib/Format/MacroCallReconstructor.cpp

 // the token, its parent and whether it is the first token in the line.
 template <typename T>
 void forEachToken(const UnwrappedLine &Line, const T &Call,
                   FormatToken *Parent = nullptr) {
   bool First = true;
   for (const auto &N : Line.Tokens) {
     Call(N.Tok, Parent, First);
     First = false;
-    for (const auto &Child : N.Children) {
+    for (const auto &Child : N.Children)
       forEachToken(Child, Call, N.Tok);
-    }
-  }
-}
 
 MacroCallReconstructor::MacroCallReconstructor(
     unsigned Level,
     const llvm::DenseMap<FormatToken *, std::unique_ptr<UnwrappedLine>>
         &ActiveExpansions)
     : Level(Level), IdToReconstructed(ActiveExpansions) {
   Result.Tokens.push_back(std::make_unique<LineNode>());
   ActiveReconstructedLines.push_back(&Result);
 }
 
 void MacroCallReconstructor::addLine(const UnwrappedLine &Line) {
   assert(State != Finalized);
   LLVM_DEBUG(llvm::dbgs() << "MCR: new line...\n");
   forEachToken(Line, [&](FormatToken *Token, FormatToken *Parent, bool First) {
     add(Token, Parent, First);
   });
   assert(InProgress || finished());
 }
 
 UnwrappedLine MacroCallReconstructor::takeResult() && {
   finalize();
-  assert(Result.Tokens.size() == 1 && Result.Tokens.front()->Children.size() == 1);
+  assert(Result.Tokens.size() == 1 &&
+         Result.Tokens.front()->Children.size() == 1);
   UnwrappedLine Final =
       createUnwrappedLine(*Result.Tokens.front()->Children.front(), Level);
   assert(!Final.Tokens.empty());
   return Final;
 }
 
 // Reconstruct the position of the next \p Token, given its parent \p
 // ExpandedParent in the incoming unwrapped line. \p First specifies whether it

 }
 
 // For a given \p Parent in the incoming expanded token stream, find the
 // corresponding parent in the output.
 FormatToken *MacroCallReconstructor::getParentInResult(FormatToken *Parent) {
   FormatToken *Mapped = SpelledParentToReconstructedParent.lookup(Parent);
   if (!Mapped)
     return Parent;
-  for (; Mapped; Mapped = SpelledParentToReconstructedParent.lookup(Parent)) {
+  for (; Mapped; Mapped = SpelledParentToReconstructedParent.lookup(Parent))
     Parent = Mapped;
-  }
   // If we use a different token than the parent in the expanded token stream
   // as parent, mark it as a special parent, so the formatting code knows it
   // needs to have its children formatted.
   Parent->MacroParent = true;
   return Parent;
 }
 
 // Reconstruct a \p Token that was expanded from a macro call.
 void MacroCallReconstructor::reconstruct(FormatToken *Token) {
   assert(Token->MacroCtx);
   // A single token can be the only result of a macro call:
   // Given: #define ID(x, y) ;
   // And the call: ID(<some>, <tokens>)
   // ';' in the expanded stream will reconstruct all of ID(<some>, <tokens>).
   if (Token->MacroCtx->StartOfExpansion) {
     startReconstruction(Token);
     // If the order of tokens in the expanded token stream is not the
     // same as the order of tokens in the reconstructed stream, we need
     // to reconstruct tokens that arrive later in the stream.
-    if (Token->MacroCtx->Role != MR_Hidden) {
+    if (Token->MacroCtx->Role != MR_Hidden)
       reconstructActiveCallUntil(Token);
-    }
-  }
   assert(!ActiveExpansions.empty());
   if (ActiveExpansions.back().SpelledI != ActiveExpansions.back().SpelledE) {
     assert(ActiveExpansions.size() == Token->MacroCtx->ExpandedFrom.size());
     if (Token->MacroCtx->Role != MR_Hidden) {
       // The current token in the reconstructed token stream must be the token
       // we're looking for - we either arrive here after startReconstruction,
       // which initiates the stream to the first token, or after
       // continueReconstructionUntil skipped until the expected token in the
for (auto T = ActiveExpansions.back().SpelledI;
       FormatToken *Token = T->Tok;
       bool ClosingParen = (std::next(T) == ActiveExpansions.back().SpelledE ||
                            std::next(T)->Tok->isTrailingComment()) &&
                           !Token->MacroCtx && Token->is(tok::r_paren);
       bool TrailingComment = Token->isTrailingComment();
       bool PreviousLevel =
           Token->MacroCtx &&
           (ActiveExpansions.size() < Token->MacroCtx->ExpandedFrom.size());
-      if (!ClosingParen && !TrailingComment && !PreviousLevel) {
+      if (!ClosingParen && !TrailingComment && !PreviousLevel)
         llvm::dbgs() << "At token: " << Token->TokenText << "\n";
-      }
       // In addition to the following cases, we can also run into this
       // when a macro call had more arguments than expected; in that case,
       // the comma and the remaining tokens in the macro call will potentially
       // end up in the line when we finish the expansion.
       // FIXME: Add the information which arguments are unused, and assert
       // one of the cases below plus reconstructed macro argument tokens.
       // assert(ClosingParen || TrailingComment || PreviousLevel);
     }

 // If visible, add the next token of the reconstructed token sequence to the
 // output. Returns whether reconstruction passed a comma that is part of a
 // macro call.
 bool MacroCallReconstructor::processNextReconstructed() {
   FormatToken *Token = ActiveExpansions.back().SpelledI->Tok;
   ++ActiveExpansions.back().SpelledI;
   if (Token->MacroCtx) {
     // Skip tokens that are not part of the macro call.
-    if (Token->MacroCtx->Role == MR_Hidden) {
+    if (Token->MacroCtx->Role == MR_Hidden)
       return false;
-    }
     // Skip tokens we already expanded during an inner reconstruction.
     // For example, given: #define ID(x) {x}
     // And the call: ID(ID(f))
     // We get two reconstructions:
     // ID(f) -> {f}
     // ID({f}) -> {{f}}
     // We reconstruct f during the first reconstruction, and skip it during the
     // second reconstruction.
-    if (ActiveExpansions.size() < Token->MacroCtx->ExpandedFrom.size()) {
+    if (ActiveExpansions.size() < Token->MacroCtx->ExpandedFrom.size())
       return false;
-    }
-  }
   // Tokens that do not have a macro context are tokens in that are part of the
   // macro call that have not taken part in expansion.
   if (!Token->MacroCtx) {
     // Put the parentheses and commas of a macro call into the same line;
     // if the arguments produce new unwrapped lines, they will become children
     // of the corresponding opening parenthesis or comma tokens in the
     // reconstructed call.
     if (Token->is(tok::l_paren)) {

clang/lib/Format/TokenAnnotator.cpp

if (PreviousNotConst->is(TT_PointerOrReference))
       return true;
 
     // MyClass a;
     if (PreviousNotConst->isSimpleTypeSpecifier())
       return true;
 
     // type[] a in Java
     if (Style.Language == FormatStyle::LK_Java &&
-        PreviousNotConst->is(tok::r_square))
+        PreviousNotConst->is(tok::r_square)) {
       return true;
+    }
 
     // const a = in JavaScript.
     return Style.isJavaScript() && PreviousNotConst->is(tok::kw_const);
   }
 
   /// Determine whether '(' is starting a C++ cast.
   bool lParenStartsCppCast(const FormatToken &Tok) {
     // C-style casts are only used in C++.
TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
     // This by itself is not sufficient to distinguish from multiplication
     // following a brace-initialized expression, as in:
     // int i = int{42} * 2;
     // In the struct case, the part of the struct declaration until the `{` and
     // the `}` are put on separate unwrapped lines; in the brace-initialized
     // case, the matching `{` is on the same unwrapped line, so check for the
     // presence of the matching brace to distinguish between those.
     if (PrevToken->is(tok::r_brace) && Tok.is(tok::star) &&
-        !PrevToken->MatchingParen)
+        !PrevToken->MatchingParen) {
       return TT_PointerOrReference;
+    }
 
     if (PrevToken->endsSequence(tok::r_square, tok::l_square, tok::kw_delete))
       return TT_UnaryOperator;
 
     if (PrevToken->Tok.isLiteral() ||
         PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::kw_true,
                            tok::kw_false, tok::r_brace)) {
       return TT_BinaryOperator;