Page MenuHomePhabricator

D59210.id190100.diff
No OneTemporary

File Metadata

Created
Mon, Feb 24, 1:40 AM

D59210.id190100.diff

Index: cfe/trunk/lib/Format/UnwrappedLineParser.cpp
===================================================================
--- cfe/trunk/lib/Format/UnwrappedLineParser.cpp
+++ cfe/trunk/lib/Format/UnwrappedLineParser.cpp
@@ -1401,6 +1401,8 @@
if (!tryToParseLambdaIntroducer())
return false;
+ bool SeenArrow = false;
+
while (FormatTok->isNot(tok::l_brace)) {
if (FormatTok->isSimpleTypeSpecifier()) {
nextToken();
@@ -1423,8 +1425,19 @@
case tok::coloncolon:
case tok::kw_mutable:
case tok::kw_noexcept:
+ nextToken();
+ break;
// Specialization of a template with an integer parameter can contain
// arithmetic, logical, comparison and ternary operators.
+ //
+ // FIXME: This also accepts sequences of operators that are not in the scope
+ // of a template argument list.
+ //
+ // In a C++ lambda a template type can only occur after an arrow. We use
+ // this as an heuristic to distinguish between Objective-C expressions
+ // followed by an `a->b` expression, such as:
+ // ([obj func:arg] + a->b)
+ // Otherwise the code below would parse as a lambda.
case tok::plus:
case tok::minus:
case tok::exclaim:
@@ -1444,13 +1457,17 @@
case tok::colon:
case tok::kw_true:
case tok::kw_false:
- nextToken();
- break;
+ if (SeenArrow) {
+ nextToken();
+ break;
+ }
+ return true;
case tok::arrow:
// This might or might not actually be a lambda arrow (this could be an
// ObjC method invocation followed by a dereferencing arrow). We might
// reset this back to TT_Unknown in TokenAnnotator.
FormatTok->Type = TT_LambdaArrow;
+ SeenArrow = true;
nextToken();
break;
default:
Index: cfe/trunk/unittests/Format/FormatTestObjC.cpp
===================================================================
--- cfe/trunk/unittests/Format/FormatTestObjC.cpp
+++ cfe/trunk/unittests/Format/FormatTestObjC.cpp
@@ -1329,6 +1329,34 @@
" @\"fffff\"];");
}
+TEST_F(FormatTestObjC, DisambiguatesCallsFromCppLambdas) {
+ verifyFormat("x = ([a foo:bar] && b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] + b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] + !b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] + ~b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] - b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] / b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] % b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] | b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] || b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] && b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] == b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] != b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] <= b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] >= b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] << b->c == 'd');");
+ verifyFormat("x = ([a foo:bar] ? b->c == 'd' : 'e');");
+ // FIXME: The following are wrongly classified as C++ lambda expressions.
+ // For example this code:
+ // x = ([a foo:bar] & b->c == 'd');
+ // is formatted as:
+ // x = ([a foo:bar] & b -> c == 'd');
+ // verifyFormat("x = ([a foo:bar] & b->c == 'd');");
+ // verifyFormat("x = ([a foo:bar] > b->c == 'd');");
+ // verifyFormat("x = ([a foo:bar] < b->c == 'd');");
+ // verifyFormat("x = ([a foo:bar] >> b->c == 'd');");
+}
+
} // end namespace
} // end namespace format
} // end namespace clang

Event Timeline