Improve formatting of lambda functions.

[jdennett]

Summary

Don't let the trailing '*' of a lambda's explicitly-specified return
type be immediately adjacent to the left brace that starts the body
of the lambda.

Before: int *p = []() -> int *{ return nullptr; }();
After: int *p = []() -> int * { return nullptr; }();

[djasper]

I am not actually sure here. The pro is that it doesn't really belong with the "{". The con is that it looks a lot more like a multiplication. Not so important for "int", but as soon as you have something where you aren't exactly sure that it is a type, this can get confusing.

Also, there is the consistency with "int *f() { return nullptr; }" which we should think about.

All in all, I don't see compelling reasons to do this change yet (but I can be convinced).

All of this just shows that the pointer belongs with the type ;-).

[chandlerc]

I think we should do this, and I'll try to give a plausibly principled rationale.

We have two uses of {}s that I care about: braced init lists and blocks. For braced init lists, we routinely omit padding spaces around the {}s:

foo({x, y z});
return {{1, 2, 3}};

On the other hand, with every block example I can come up with, we have spaces around the {}s:

if (...) {
}

int f() {
}

auto f() {
}

auto f() -> int {
}

[] {}, []() {}, []() mutable {}, []() -> int {}

It makes much more sense to me to have a space even in the presence of a pointer (or reference).

[djasper]

Those examples are very selective, though:

someFunction(a, {1, 2, 3});
Debug({ llvm::errs() << "abc\n"; });
SomeIntType b = a * {7};

[djasper]

Ok. To be clear, I don't care strongly at all. If the two of you are convinced this is better, lets just put it in.

How does this relate to "int *f();"? Do we simply not care about that consistency at this point as this is about spacing out braces?

[djasper]

Submitted slightly modified patch as r239600. Thanks!

lib/Format/TokenAnnotator.cpp

if (Right.is(TT_TemplateOpener) && Left.is(tok::r_paren) &&
     return false;
   if (Right.is(tok::less) && Left.isNot(tok::l_paren) &&
       Line.First->is(tok::hash))
     return true;
   if (Right.is(TT_TrailingUnaryOperator))
     return false;
   if (Left.is(TT_RegexLiteral))
     return false;
+
+  // `[]() -> T *{` needs a space inserted before the left brace.
+  if (Left.is(TT_PointerOrReference) && Right.is(tok::l_brace))
+    return true;
+
   return spaceRequiredBetween(Line, Left, Right);
 }
 
 // Returns 'true' if 'Tok' is a brace we'd want to break before in Allman style.
 static bool isAllmanBrace(const FormatToken &Tok) {
   return Tok.is(tok::l_brace) && Tok.BlockKind == BK_Block &&
          !Tok.isOneOf(TT_ObjCBlockLBrace, TT_DictLiteral);
 }

unittests/Format/FormatTest.cpp

EXPECT_EQ("int i;\n"
                    "   int   k;"));
 }
 
 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
   format("? ) =");
   verifyNoCrash("#define a\\\n /**/}");
 }
 
+TEST_F(FormatTest, IncludeSpaceBeforeLambdaBody) {
+  verifyFormat("int *p = []() -> int * { return nullptr; }();");
+}
+
 } // end namespace tooling
 } // end namespace clang