[CUDA] Handle attributes on CUDA lambdas appearing between [...] and (...).

[jlebar]

Summary

This is ugh, but it makes us compatible with NVCC. Fixes bug 26341.

[rnk]

clang/lib/Parse/ParseExprCXX.cpp

1135 ↗

(On Diff #73071)

Does nvcc support __declspec style attributes? Maybe we should check for those too?

1280 ↗

(On Diff #73071)

Let's not duplicate this amazingly long type info thingy. I think you can avoid it if you hoist MutableLoc and add a bool like NeedFuncDeclaratorChunk. Also, maybe we shouldn't be hallucinating a function declarator chunk in CUDA when there are no attributes?

[jlebar]

Don't hallucinate a function declarator.

clang/lib/Parse/ParseExprCXX.cpp

1135 ↗

(On Diff #73071)

nvcc doesn't seem to support __declspec attributes.

I have no strong opinion on whether or not we should add them ourselves, though I guess I have a weak aversion to mucking with the parsing rules more than is necessary. (I put off this patch for as long as I could while I tried to get nvcc to put the attributes in the right place.)

1280 ↗

(On Diff #73071)

Oh, I didn't look closely enough at the API to realize that I could add attributes without creating a new function declarator chunk. New patch is a much smaller change.

[rnk]

lgtm

clang/lib/Parse/ParseExprCXX.cpp

1135 ↗

(On Diff #73071)

Nope, let's leave declspec alone then. :)

cfe/trunk/lib/Parse/ParseExprCXX.cpp

ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
 
   // 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);
   TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
-  Actions.PushLambdaScope();    
+  Actions.PushLambdaScope();
 
+  ParsedAttributes Attr(AttrFactory);
+  SourceLocation DeclLoc = Tok.getLocation();
+  SourceLocation DeclEndLoc = DeclLoc;
+  if (getLangOpts().CUDA) {
+    // In CUDA code, GNU attributes are allowed to appear immediately after the
+    // "[...]", even if there is no "(...)" before the lambda body.
+    MaybeParseGNUAttributes(Attr, &DeclEndLoc);
+    D.takeAttributes(Attr, DeclEndLoc);
+  }
+
   TypeResult TrailingReturnType;
   if (Tok.is(tok::l_paren)) {
     ParseScope PrototypeScope(this,
                               Scope::FunctionPrototypeScope |
                               Scope::FunctionDeclarationScope |
                               Scope::DeclScope);
 
-    SourceLocation DeclEndLoc;
     BalancedDelimiterTracker T(*this, tok::l_paren);
     T.consumeOpen();
     SourceLocation LParenLoc = T.getOpenLocation();
 
     // Parse parameter-declaration-clause.
-    ParsedAttributes Attr(AttrFactory);
     SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
     SourceLocation EllipsisLoc;
     
     if (Tok.isNot(tok::r_paren)) {
       Actions.RecordParsingTemplateParameterDepth(TemplateParameterDepth);
       ParseParameterDeclarationClause(D, Attr, ParamInfo, EllipsisLoc);
       // For a generic lambda, each 'auto' within the parameter declaration 
       // clause creates a template type parameter, so increment the depth.
if (Tok.is(tok::l_paren)) {
     case tok::l_square: TokKind = 2; break;
     case tok::kw_constexpr: TokKind = 3; break;
     default: llvm_unreachable("Unknown token kind");
     }
 
     Diag(Tok, diag::err_lambda_missing_parens)
       << TokKind
       << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
-    SourceLocation DeclLoc = Tok.getLocation();
-    SourceLocation DeclEndLoc = DeclLoc;
+    DeclEndLoc = DeclLoc;
 
     // GNU-style attributes must be parsed before the mutable specifier to be
     // compatible with GCC.
-    ParsedAttributes Attr(AttrFactory);
     MaybeParseGNUAttributes(Attr, &DeclEndLoc);
 
     // Parse 'mutable', if it's there.
     SourceLocation MutableLoc;
     if (Tok.is(tok::kw_mutable)) {
       MutableLoc = ConsumeToken();
       DeclEndLoc = MutableLoc;
     }
D.AddTypeInfo(DeclaratorChunk::getFunction(/*hasProto=*/true,
                                                /*ExceptionRanges=*/nullptr,
                                                /*NumExceptions=*/0,
                                                /*NoexceptExpr=*/nullptr,
                                                /*ExceptionSpecTokens=*/nullptr,
                                                DeclLoc, DeclEndLoc, D,
                                                TrailingReturnType),
                   Attr, DeclEndLoc);
   }
-  
-
   // FIXME: Rename BlockScope -> ClosureScope if we decide to continue using
   // it.
   unsigned ScopeFlags = Scope::BlockScope | Scope::FnScope | Scope::DeclScope;
   ParseScope BodyScope(this, ScopeFlags);
 
   Actions.ActOnStartOfLambdaDefinition(Intro, D, getCurScope());
 
   // Parse compound-statement.

cfe/trunk/test/Parser/lambda-attr.cu

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcuda-is-device -verify %s
+
+// expected-no-diagnostics
+
+__attribute__((device)) void device_fn() {}
+__attribute__((device)) void hd_fn() {}
+
+__attribute__((device)) void device_attr() {
+  ([]() __attribute__((device)) { device_fn(); })();
+  ([] __attribute__((device)) () { device_fn(); })();
+  ([] __attribute__((device)) { device_fn(); })();
+
+  ([&]() __attribute__((device)){ device_fn(); })();
+  ([&] __attribute__((device)) () { device_fn(); })();
+  ([&] __attribute__((device)) { device_fn(); })();
+
+  ([&](int) __attribute__((device)){ device_fn(); })(0);
+  ([&] __attribute__((device)) (int) { device_fn(); })(0);
+}
+
+__attribute__((host)) __attribute__((device)) void host_device_attrs() {
+  ([]() __attribute__((host)) __attribute__((device)){ hd_fn(); })();
+  ([] __attribute__((host)) __attribute__((device)) () { hd_fn(); })();
+  ([] __attribute__((host)) __attribute__((device)) { hd_fn(); })();
+
+  ([&]() __attribute__((host)) __attribute__((device)){ hd_fn(); })();
+  ([&] __attribute__((host)) __attribute__((device)) () { hd_fn(); })();
+  ([&] __attribute__((host)) __attribute__((device)) { hd_fn(); })();
+
+  ([&](int) __attribute__((host)) __attribute__((device)){ hd_fn(); })(0);
+  ([&] __attribute__((host)) __attribute__((device)) (int) { hd_fn(); })(0);
+}