Add a new clang-format style option ObjCBlockResetsIndent.

[yixiang]

Summary

Add a new clang-format style option ObjCBlockResetsIndent of type bool. It defaults to false.
When true, ObjC blocks resets indentation to that of its owner block.
The resetting behavior is often desirable, as it leaves more columns for the content of the ObjC block.

E.g. for an unformatted file test.m like this:

- (void)test {
[self callAVeryVeryVeryVeryVeryVeryLongAsyncMethodWith:@"Some param"
completionHandler:^() {
[self callAnotherLongMethodHereWith:@"param"];
}];
}

- (void)test2 {
[self callAsychronousMethodWith:@"Some param"
failureHandler:^() {
[self handleFailure];
}
successHandler:^() {
[self handleSuccess];
}];
}

The formatted result with ObjCBlockResetsIndent=false (or omitted) is this:

// clang-format -style='{ObjCBlockResetsIndent: false}' test.m
// OR
// clang-format test.m
- (void)test {
  [self callAVeryVeryVeryVeryVeryVeryLongAsyncMethodWith:@"Some param"
                                       completionHandler:^() {
                                         [self callAnotherLongMethodHereWith:@"param"];
                                       }];
}

- (void)test2 {
  [self callAsychronousMethodWith:@"Some param"
      failureHandler:^() {
        [self handleFailure];
      }
      successHandler:^() {
        [self handleSuccess];
      }];
}

The formatted result with ObjCBlockResetsIndent=true is this:

// clang-format -style='{ObjCBlockResetsIndent: true}' test.m
- (void)test {
  [self callAVeryVeryVeryVeryVeryVeryLongAsyncMethodWith:@"Some param"
                                       completionHandler:^() {
    [self callAnotherLongMethodHereWith:@"param"];
  }];
}

- (void)test2 {
  [self callAsychronousMethodWith:@"Some param"
      failureHandler:^() {
        [self handleFailure];
      }
      successHandler:^() {
        [self handleSuccess];
      }];
}

[djasper]

I think generally, this makes sense.

Can you add tests in unittests/Format/FormatTest.cpp (probably next to TEST_F(FormatTest, FormatsBlocks) {..})?
What's the behavior when there is more than one block?

Also note that we have some requirements for additional options (mainly to ensure long-term maintainability):
http://clang.llvm.org/docs/ClangFormatStyleOptions.html#adding-additional-style-options

[yixiang]

• Added unit test for ObjCBlockResetsIndent.

[yixiang]

Can you add tests in unittests/Format/FormatTest.cpp (probably next to TEST_F(FormatTest, FormatsBlocks) {..})?
What's the behavior when there is more than one block?

Unit tests added.

Also note that we have some requirements for additional options (mainly to ensure long-term maintainability):
http://clang.llvm.org/docs/ClangFormatStyleOptions.html#adding-additional-style-options

Thanks for pointing that out to me.

[yixiang]

• Don't reset indent for statements with multiple blocks.

[yixiang]

Discover a case where my code breaks. When the block signature has a return type in it, the indent doesn't gets reset properly. I need to fix this.

[UPDATE]

The testing code was with incorrect syntax. The code is actually ready for review.

[yixiang]

Ping.

For the additional requirements of adding a style options:

• be used in a project of significant size (have dozens of contributors)
  • Yes, it's been used by almost all the iOS projects inside Google, including Google Maps.
• have a publicly accessible style guide
  • https://google.github.io/styleguide/objcguide.xml
• have a person willing to contribute and maintain patches
  • I'm willing to do the maintenance, I'm confident that I can find backup contributors too.

docs/ClangFormatStyleOptions.rst

**NamespaceIndentation** (``NamespaceIndentationKind``)
   * ``NI_All`` (in configuration: ``All``)
     Indent in all namespaces.
 
 
 
 **ObjCBlockIndentWidth** (``unsigned``)
   The number of characters to use for indentation of ObjC blocks.
 
+**ObjCBlockResetsIndent** (``bool``)
+  Reset the indent of an ObjC block to that of its owner statement
+  if the statement has only one embedded block.
+
 **ObjCSpaceAfterProperty** (``bool``)
   Add a space after ``@property`` in Objective-C, i.e. use
   ``@property (readonly)`` instead of ``@property(readonly)``.
 
 **ObjCSpaceBeforeProtocolList** (``bool``)
   Add a space in front of an Objective-C protocol list, i.e. use
   ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
 

include/clang/Format/Format.h

struct FormatStyle {
   };
 
   /// \brief The indentation used for namespaces.
   NamespaceIndentationKind NamespaceIndentation;
 
   /// \brief The number of characters to use for indentation of ObjC blocks.
   unsigned ObjCBlockIndentWidth;
 
+  /// \brief Reset the indent of an ObjC block to that of its owner statement
+  /// if the statement has only one embedded block.
+  bool ObjCBlockResetsIndent = false;
+
   /// \brief Add a space after ``@property`` in Objective-C, i.e. use
   /// ``@property (readonly)`` instead of ``@property(readonly)``.
   bool ObjCSpaceAfterProperty;
 
   /// \brief Add a space in front of an Objective-C protocol list, i.e. use
   /// ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
   bool ObjCSpaceBeforeProtocolList;
 

lib/Format/ContinuationIndenter.cpp

if (Current.is(tok::r_square)) {
     // If this ends the array subscript expr, reset the corresponding value.
     const FormatToken *NextNonComment = Current.getNextNonComment();
     if (NextNonComment && NextNonComment->isNot(tok::l_square))
       State.Stack.back().StartOfArraySubscripts = 0;
   }
 }
 
 void ContinuationIndenter::moveStateToNewBlock(LineState &State) {
+  // Reset the indent of an ObjC block to that of its owner statement if the
+  // statement has only one embedded block.
+  if (Style.ObjCBlockResetsIndent &&
+      State.NextToken->is(TT_ObjCBlockLBrace) &&
+      (State.Stack.size() < 2 ||
+       !State.Stack[State.Stack.size() - 2].HasMultipleNestedBlocks)) {
+    State.Stack.back().Indent = State.Stack.front().Indent;
+    State.Stack.back().NestedBlockIndent =
+        State.Stack.front().NestedBlockIndent;
+  }
   unsigned NestedBlockIndent = State.Stack.back().NestedBlockIndent;
   // ObjC block sometimes follow special indentation rules.
   unsigned NewIndent =
       NestedBlockIndent + (State.NextToken->is(TT_ObjCBlockLBrace)
                                ? Style.ObjCBlockIndentWidth
                                : Style.IndentWidth);
   State.Stack.push_back(ParenState(
       NewIndent, /*NewIndentLevel=*/State.Stack.back().IndentLevel + 1,

lib/Format/Format.cpp

static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("JavaScriptWrapImports", Style.JavaScriptWrapImports);
     IO.mapOptional("KeepEmptyLinesAtTheStartOfBlocks",
                    Style.KeepEmptyLinesAtTheStartOfBlocks);
     IO.mapOptional("MacroBlockBegin", Style.MacroBlockBegin);
     IO.mapOptional("MacroBlockEnd", Style.MacroBlockEnd);
     IO.mapOptional("MaxEmptyLinesToKeep", Style.MaxEmptyLinesToKeep);
     IO.mapOptional("NamespaceIndentation", Style.NamespaceIndentation);
     IO.mapOptional("ObjCBlockIndentWidth", Style.ObjCBlockIndentWidth);
+    IO.mapOptional("ObjCBlockResetsIndent", Style.ObjCBlockResetsIndent);
     IO.mapOptional("ObjCSpaceAfterProperty", Style.ObjCSpaceAfterProperty);
     IO.mapOptional("ObjCSpaceBeforeProtocolList",
                    Style.ObjCSpaceBeforeProtocolList);
     IO.mapOptional("PenaltyBreakBeforeFirstCallParameter",
                    Style.PenaltyBreakBeforeFirstCallParameter);
     IO.mapOptional("PenaltyBreakComment", Style.PenaltyBreakComment);
     IO.mapOptional("PenaltyBreakFirstLessLess",
                    Style.PenaltyBreakFirstLessLess);

unittests/Format/FormatTest.cpp

TEST_F(FormatTest, FormatsBlocks) {
   FormatStyle FourIndent = getLLVMStyle();
   FourIndent.ObjCBlockIndentWidth = 4;
   verifyFormat("[operation setCompletionBlock:^{\n"
                "    [self onOperationDone];\n"
                "}];",
                FourIndent);
 }
 
+TEST_F(FormatTest, FormatsBlocksWithIndentResetting) {
+  FormatStyle ShortBlocks = getLLVMStyle();
+  ShortBlocks.AllowShortBlocksOnASingleLine = true;
+  ShortBlocks.ObjCBlockResetsIndent = true;
+
+  verifyFormat("int (^Block)(int, int);", ShortBlocks);
+  verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
+  verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
+  verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
+  verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
+  verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
+
+  verifyFormat("foo(^{ bar(); });", ShortBlocks);
+  verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
+  verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
+
+  verifyFormat("[operation setCompletionBlock:^{\n"
+               "  [self onOperationDone];\n"
+               "}];");
+  verifyFormat("int i = {[operation setCompletionBlock:^{\n"
+               "  [self onOperationDone];\n"
+               "}]};");
+
+  verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
+               "  f();\n"
+               "}];");
+
+  verifyFormat("int a = [operation block:^int(int *i) {\n"
+               "  return 1;\n"
+               "}];");
+
+  FormatStyle ResetsIndent = getLLVMStyle();
+  ResetsIndent.ObjCBlockResetsIndent = true;
+  verifyFormat("[myObject doSomethingWith:arg1\n"
+               "                      aaa:^int(int *a) {\n"
+               "  return 1;\n"
+               "}\n"
+               "                      bbb:f(a * bbbbbbbb)];",
+               ResetsIndent);
+
+  verifyFormat("[operation setCompletionBlock:^{\n"
+               "  [self.delegate newDataAvailable];\n"
+               "}];",
+               ResetsIndent);
+  verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
+               "  NSString *path = [self sessionFilePath];\n"
+               "  if (path) {\n"
+               "    // ...\n"
+               "  }\n"
+               "});",
+               ResetsIndent);
+  verifyFormat("[[SessionService sharedService]\n"
+               "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
+               "  if (window) {\n"
+               "    [self windowDidLoad:window];\n"
+               "  } else {\n"
+               "    [self errorLoadingWindow];\n"
+               "  }\n"
+               "}];",
+               ResetsIndent);
+  verifyFormat("void (^largeBlock)(void) = ^{\n"
+               "  // ...\n"
+               "};\n",
+               ResetsIndent);
+
+  FormatStyle ResetsIndent60 = getLLVMStyleWithColumns(60);
+  ResetsIndent60.ObjCBlockResetsIndent = true;
+  verifyFormat("[[SessionService sharedService]\n"
+               "    loadWindowWithCompletionBlock: //\n"
+               "        ^(SessionWindow *window) {\n"
+               "  if (window) {\n"
+               "    [self windowDidLoad:window];\n"
+               "  } else {\n"
+               "    [self errorLoadingWindow];\n"
+               "  }\n"
+               "}];",
+               ResetsIndent60);
+
+  verifyFormat("[myObject doSomethingWith:arg1\n"
+               "    firstBlock:^(Foo *a) {\n"
+               "      // ...\n"
+               "      int i;\n"
+               "    }\n"
+               "    secondBlock:^(Bar *b) {\n"
+               "      // ...\n"
+               "      int i;\n"
+               "    }\n"
+               "    thirdBlock:^Foo(Bar *b) {\n"
+               "      // ...\n"
+               "      int i;\n"
+               "    }];",
+               ResetsIndent);
+  verifyFormat("[myObject doSomethingWith:arg1\n"
+               "               firstBlock:-1\n"
+               "              secondBlock:^(Bar *b) {\n"
+               "  // ...\n"
+               "  int i;\n"
+               "}];",
+               ResetsIndent);
+
+  verifyFormat("f(^{\n"
+               "  @autoreleasepool {\n"
+               "    if (a) {\n"
+               "      g();\n"
+               "    }\n"
+               "  }\n"
+               "});",
+               ResetsIndent);
+  verifyFormat("Block b = ^int *(A *a, B *b) {}", ResetsIndent);
+  verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
+               "};",
+               ResetsIndent);
+
+  FormatStyle FourIndent = getLLVMStyle();
+  FourIndent.ObjCBlockIndentWidth = 4;
+  FourIndent.ObjCBlockResetsIndent = true;
+  verifyFormat("[operation setCompletionBlock:^{\n"
+               "    [self onOperationDone];\n"
+               "}];",
+               FourIndent);
+}
+
 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
   FormatStyle ZeroColumn = getLLVMStyle();
   ZeroColumn.ColumnLimit = 0;
 
   verifyFormat("[[SessionService sharedService] "
                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
                "  if (window) {\n"
                "    [self windowDidLoad:window];\n"