def note_lambda_to_block_conv : Note<
"implicit capture of lambda object due to conversion to block pointer "
"here">;
+ def err_lambda_init_capture_unsupported : Error<
+ "sorry, initialized lambda-captures are not supported yet">;
}
def err_return_in_captured_stmt : Error<
struct LambdaCapture {
LambdaCaptureKind Kind;
SourceLocation Loc;
- IdentifierInfo* Id;
+ IdentifierInfo *Id;
SourceLocation EllipsisLoc;
-
+ ExprResult Init;
+
LambdaCapture(LambdaCaptureKind Kind, SourceLocation Loc,
IdentifierInfo* Id = 0,
- SourceLocation EllipsisLoc = SourceLocation())
- : Kind(Kind), Loc(Loc), Id(Id), EllipsisLoc(EllipsisLoc)
+ SourceLocation EllipsisLoc = SourceLocation(),
+ ExprResult Init = ExprResult())
+ : Kind(Kind), Loc(Loc), Id(Id), EllipsisLoc(EllipsisLoc), Init(Init)
{}
};
/// \brief Append a capture in a lambda introducer.
void addCapture(LambdaCaptureKind Kind,
SourceLocation Loc,
- IdentifierInfo* Id = 0,
- SourceLocation EllipsisLoc = SourceLocation()) {
- Captures.push_back(LambdaCapture(Kind, Loc, Id, EllipsisLoc));
+ IdentifierInfo* Id = 0,
+ SourceLocation EllipsisLoc = SourceLocation(),
+ ExprResult Init = ExprResult()) {
+ Captures.push_back(LambdaCapture(Kind, Loc, Id, EllipsisLoc, Init));
}
-
};
} // end namespace clang
Tok.is(tok::l_paren), isAddressOfOperand);
}
-/// ParseLambdaExpression - Parse a C++0x lambda expression.
+/// ParseLambdaExpression - Parse a C++11 lambda expression.
///
/// lambda-expression:
/// lambda-introducer lambda-declarator[opt] compound-statement
/// capture-list ',' capture
///
/// capture:
+/// simple-capture
+/// init-capture [C++1y]
+///
+/// simple-capture:
/// identifier
/// '&' identifier
/// 'this'
///
+/// init-capture: [C++1y]
+/// identifier initializer
+/// '&' identifier initializer
+///
/// lambda-declarator:
/// '(' parameter-declaration-clause ')' attribute-specifier[opt]
/// 'mutable'[opt] exception-specification[opt]
SourceLocation Loc;
IdentifierInfo* Id = 0;
SourceLocation EllipsisLoc;
+ ExprResult Init;
if (Tok.is(tok::kw_this)) {
Kind = LCK_This;
} else {
return DiagResult(diag::err_expected_capture);
}
+
+ if (Tok.is(tok::l_paren)) {
+ BalancedDelimiterTracker Parens(*this, tok::l_paren);
+ Parens.consumeOpen();
+
+ ExprVector Exprs;
+ CommaLocsTy Commas;
+ if (ParseExpressionList(Exprs, Commas)) {
+ Parens.skipToEnd();
+ Init = ExprError();
+ } else {
+ Parens.consumeClose();
+ Init = Actions.ActOnParenListExpr(Parens.getOpenLocation(),
+ Parens.getCloseLocation(),
+ Exprs);
+ }
+ } else if (Tok.is(tok::l_brace) || Tok.is(tok::equal)) {
+ if (Tok.is(tok::equal))
+ ConsumeToken();
+
+ Init = ParseInitializer();
+ }
}
- Intro.addCapture(Kind, Loc, Id, EllipsisLoc);
+ Intro.addCapture(Kind, Loc, Id, EllipsisLoc, Init);
}
T.consumeClose();
PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
"lambda expression parsing");
+ // FIXME: Call into Actions to add any init-capture declarations to the
+ // scope while parsing the lambda-declarator and compound-statement.
+
// Parse lambda-declarator[opt].
DeclSpec DS(AttrFactory);
Declarator D(DS, Declarator::LambdaExprContext);
continue;
}
+ // FIXME: C++1y [expr.prim.lambda]p11
+ if (C->Init.isInvalid())
+ continue;
+ if (C->Init.isUsable()) {
+ Diag(C->Loc, diag::err_lambda_init_capture_unsupported);
+ continue;
+ }
+
assert(C->Id && "missing identifier for capture");
// C++11 [expr.prim.lambda]p8:
delete [] { return new int; } (); // expected-error{{expected expression}}
delete [&] { return new int; } (); // ok, lambda
}
+
+ // We support init-captures in C++11 as an extension.
+ int z;
+ void init_capture() {
+ // FIXME: These diagnostics should all disappear once semantic analysis
+ // for init-captures is complete.
+ [n(0)] () -> int { return ++n; }; // expected-error {{not supported}} expected-error {{undeclared}}
+ [n{0}] { return; }; // expected-error {{not supported}}
+ [n = 0] { return ++n; }; // expected-error {{not supported}} expected-error {{undeclared}}
+ [n = {0}] { return; }; // expected-error {{not supported}}
+ [a([&b = z]{})](){}; // expected-error 2{{not supported}}
+
+ int x = 4; // expected-note {{here}}
+ auto y = [&r = x, x = x + 1]() -> int { // expected-error 2{{not supported}} expected-note {{here}}
+ r += 2; // expected-error {{undeclared}}
+ return x + 2; // expected-error {{implicitly captured}}
+ } ();
+ }
};
[foo,bar] () { return 3; };
[=,&foo] () {};
[this] () {};
+
+ [foo(bar)] () {}; // expected-error {{not supported}}
+ [foo = bar] () {}; // expected-error {{not supported}}
+ [foo{bar}] () {}; // expected-error {{not supported}}
+ [foo = {bar}] () {}; // expected-error {{not supported}}
+
+ [foo(bar) baz] () {}; // expected-error {{called object type 'int' is not a function}}
+
+ // FIXME: These are some appalling diagnostics.
+ [foo = bar baz]; // expected-error {{missing '['}} expected-warning 2{{receiver type 'int'}} expected-warning 2{{instance method '-baz'}}
}
};