[clang-format] Add support for C++17 structured bindings.

[curdeius]

Summary

Before:

auto[a, b] = f();

After:

auto [a, b] = f();

or, if SpacesInSquareBrackets is true:

auto [ a, b ] = f();

[djasper]

Are you changing the line endings here? Phabricator tells me that basically all the lines change. If so, please don't ;).

lib/Format/TokenAnnotator.cpp

345

I'd prefer to move this into a separate function or a lambda, i.e.:

bool isCppStructuredBinding(const FormatToken *Tok) {
  if (!Style.isCpp() || !Tok->is(tok::l_square))
    return false;
  while (Tok && Tok->isOneOf(tok::kw_const, tok::kw_volatile, tok::amp, tok::ampamp))
    Tok = Tok->getPreviousNonComment()) {
  return Tok && Tok->is(tok::kw_auto);
}

[curdeius]

Fix line endings.

[curdeius]

Revert unintended format changes.

[curdeius]

Fix line endings again.

[curdeius]

Extract method.

[curdeius]

Fix: use do-while loop.

[djasper]

Looks good. Sorry for the delay.

[chh]

Thanks for this change.
Could you take a look of https://reviews.llvm.org/D35743 too?

This outputs a space before and after "&" or "&&", like this

"auto & [...",  "auto && [..."

Could we remove one of the space to a format like the following?

"auto& [...",  "auto&& [..."

[chh]

Please review https://reviews.llvm.org/D35743.
I uploaded there a new diff that should fix the spaces around & and && tokens.
Thanks.

lib/Format/FormatToken.h

   TYPE(RegexLiteral) \
   TYPE(SelectorName) \
   TYPE(StartOfName) \
+  TYPE(StructuredBindingLSquare) \
   TYPE(TemplateCloser) \
   TYPE(TemplateOpener) \
   TYPE(TemplateString) \

lib/Format/TokenAnnotator.cpp

     return false;
   }
 
+  bool isCppStructuredBinding(const FormatToken *Tok) {
+    if (!Style.isCpp() || !Tok->is(tok::l_square))
+      return false;
+    do {
+      Tok = Tok->getPreviousNonComment();
+    } while (Tok && Tok->isOneOf(tok::kw_const, tok::kw_volatile, tok::amp,
+                                 tok::ampamp));
+    return Tok && Tok->is(tok::kw_auto);
+  }
+
   bool parseSquare() {
     if (!CurrentToken)
       return false;

 
     unsigned BindingIncrease = 1;
     if (Left->is(TT_Unknown)) {
-      if (StartsObjCMethodExpr) {
+      if (isCppStructuredBinding(Left)) {
+        Left->Type = TT_StructuredBindingLSquare;
+      } else if (StartsObjCMethodExpr) {
         Left->Type = TT_ObjCMethodExpr;
       } else if (Style.Language == FormatStyle::LK_JavaScript && Parent &&
                  Contexts.back().ContextKind == tok::l_brace &&

   if (Left.is(tok::l_square))
     return (Left.is(TT_ArrayInitializerLSquare) &&
             Style.SpacesInContainerLiterals && Right.isNot(tok::r_square)) ||
-           (Left.is(TT_ArraySubscriptLSquare) && Style.SpacesInSquareBrackets &&
-            Right.isNot(tok::r_square));
+           (Left.isOneOf(TT_ArraySubscriptLSquare,
+                         TT_StructuredBindingLSquare) &&
+            Style.SpacesInSquareBrackets && Right.isNot(tok::r_square));
   if (Right.is(tok::r_square))
     return Right.MatchingParen &&
            ((Style.SpacesInContainerLiterals &&
              Right.MatchingParen->is(TT_ArrayInitializerLSquare)) ||
             (Style.SpacesInSquareBrackets &&
-             Right.MatchingParen->is(TT_ArraySubscriptLSquare)));
+             Right.MatchingParen->isOneOf(TT_ArraySubscriptLSquare,
+                                          TT_StructuredBindingLSquare)));
   if (Right.is(tok::l_square) &&
       !Right.isOneOf(TT_ObjCMethodExpr, TT_LambdaLSquare,
-                     TT_DesignatedInitializerLSquare) &&
+                     TT_DesignatedInitializerLSquare,
+                     TT_StructuredBindingLSquare) &&
       !Left.isOneOf(tok::numeric_constant, TT_DictLiteral))
     return false;
   if (Left.is(tok::l_brace) && Right.is(tok::r_brace))

unittests/Format/FormatTest.cpp

   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
 }
 
+TEST_F(FormatTest, StructuredBindings) {
+  // Structured bindings is a C++17 feature.
+  // all modes, including C++11, C++14 and C++17
+  verifyFormat("auto [a, b] = f();");
+  EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
+  EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
+  EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
+  EXPECT_EQ("auto const volatile [a, b] = f();",
+            format("auto  const   volatile[a, b] = f();"));
+  EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
+  EXPECT_EQ("auto & [a, b, c] = f();",
+            format("auto   &[  a  ,  b,c   ] = f();"));
+  EXPECT_EQ("auto && [a, b, c] = f();",
+            format("auto   &&[  a  ,  b,c   ] = f();"));
+  EXPECT_EQ("auto const & [a, b] = f();", format("auto  const&[a, b] = f();"));
+  EXPECT_EQ("auto const volatile && [a, b] = f();",
+            format("auto  const  volatile  &&[a, b] = f();"));
+  EXPECT_EQ("auto && [a, b] = f();", format("auto  &&[a, b] = f();"));
+
+  format::FormatStyle Spaces = format::getLLVMStyle();
+  Spaces.SpacesInSquareBrackets = true;
+  verifyFormat("auto [ a, b ] = f();", Spaces);
+  verifyFormat("auto && [ a, b ] = f();", Spaces);
+}
+
 } // end namespace
 } // end namespace format
 } // end namespace clang