Reinstate CWG1607 restrictions on lambdas appearing inside certain constant-expressions

[faisalv]

Summary

This patch disables lambda expressions (especially Immediately Invoked Lambda Expressions (IILEs, to borrow a term from the all-mighty ecmascript ;)) from appearing within potentially mangled contexts.

The approach is a rather primitive/inelegant one. Instead of enumerating all the various syntactic constant-expression contexts at a finer level of granularity and then passing that information through to each call of ParseConstantExpression, we simply set a flag that forbids lambda expressions (when we know we are in the forbidden context). There is probably an opportunity here to streamline the machinery that prohibits lambdas in certain contexts across the various versions of C++ further - but that could be re-engineered if/when Louis Dionne's paper on Lambdas in Unevaluated contexts gets incorporated into the working draft.

Would appreciate some feedback here - thanks!

[rsmith]

include/clang/Parse/Parser.h

1432

I would call this IsInSignature.

include/clang/Sema/Sema.h

894–895

Rather than adding a flag, how about we have two different kinds of ExpressionEvaluationContext for constant expressions: a generic "constant expression" context and a "constant expression in signature" context?

[faisalv]

include/clang/Sema/Sema.h

894–895

But not all lambdas that appear in template arguments are in signatures - so should we split it into ConstantEvaluated, ConstantEvaluatedInSignatureOrTemplateArg ?

lib/Parse/ParseDecl.cpp

6254

I suppose we should forbid these in a lambda parameter declaration clause too?

[faisalv]

Yes - I'll modify the patch to reflect that approach. Any thoughts on whether they should also be forbidden in Lamda parameter declaration clauses?
Thanks!

[faisalv]

The updated patch adds two additional enumerators to ExpressionEvaluationContext: ConstantEvaluatedInTemplateArgument and ConstantEvaluatedInFunctionSignature and sets them appropriately (as opposed to our previous approach of setting the IsLambdaExpressionForbidden flag in those locations).

When popping off the EvaluationContext, instead of checking the flag, we now check the EvaluationContext directly to determine if the Lambda Expression is valid.

[rsmith]

I don't think it's possible to check this in the way you're doing so here. In general, there's no way to know whether a constant expression will be part of a typedef declaration or function declaration until you've finished parsing it (when you're parsing the decl-specifiers in a declaration you don't know whether you're declaring a function or a variable, and the typedef keyword might appear later).

So I think you need a different approach here. How about tracking the set of contained lambdas on the Declarator and DeclSpec objects, and diagnose from ActOnFunctionDeclarator / ActOnTypedefDeclarator if the current expression evaluation context contains any lambdas? (Maybe when entering an expression evaluation context, pass an optional SmallVectorImpl<Expr*>* to Sema to collect the lambdas contained within the expression.)

There are some particularly "fun" cases to watch out for here:

decltype([]{})
  a, // ok
  f(); // ill-formed

... that require us to track the lambdas in the DeclSpec separately from the lambdas in the Declarator.

[faisalv]

In D28510#653794, @rsmith wrote:

I don't think it's possible to check this in the way you're doing so here. In general, there's no way to know whether a constant expression will be part of a typedef declaration or function declaration until you've finished parsing it (when you're parsing the decl-specifiers in a declaration you don't know whether you're declaring a function or a variable, and the typedef keyword might appear later).

I see. The issue is that the current approach would forbid valid variable declarations such as:

void (*f)(int [([]{return 5;}())]) = 0;

... where lambdas can appear within the array declarators (I believe that's the only syntactic neighborhood that can cause this problem, right?).

So I think you need a different approach here. How about tracking the set of contained lambdas on the Declarator and DeclSpec objects, and diagnose from ActOnFunctionDeclarator / ActOnTypedefDeclarator if the current expression evaluation context contains any lambdas? (Maybe when entering an expression evaluation context, pass an optional SmallVectorImpl<Expr*>* to Sema to collect the lambdas contained within the expression.)

Yes - I can see something along these lines working well...

There are some particularly "fun" cases to watch out for here:

decltype([]{})
  a, // ok
  f(); // ill-formed

... that require us to track the lambdas in the DeclSpec separately from the lambdas in the Declarator.

Well lambda's can't appear in unevaluated operands yet, so your example would be ill-formed? If so, we don't have to worry about them showing up in decl-specifiers?
The only Declarator where they could be well formed is within an array declarator of a variable or a parameter of a function pointer variable (but no where else, i.e typedefs and function declarations), right?

Thanks!

[faisalv]

I tried a different approach, not because I was convinced it was better, but because it seemed (at the time) a simpler tweak - I'm not sure it is robust enough - but would appreciate your thoughts on it.

The approach is predicated on the following:

• lambda expressions can only appear in types in a non-unevaluated context, within array brackets
• if we track within each parameter declarator, its parent function declarator, we can always get to the outer most declarator and if the outermost declarator has the form (ptr-op f)(...) it can not be a function declarator (but is a variable) - we can determine this without waiting for the recursion to complete (I set a special token on the declarator once we start parsing a parens declarator and the token is a ptr-operator)
• additionally we can check the context of the outermost declarator to ensure it is not within an alias-declaration or a template-argument

Based on the test cases, it seems to work well - but not sure if the test cases are exhaustive.
Also the patch needs some cleanup if we agree that this direction is worth pursuing (and not too fragile an approach).

Thanks!

Would appreciate feedback!

[rsmith]

In D28510#654821, @faisalv wrote:

In D28510#653794, @rsmith wrote:

I don't think it's possible to check this in the way you're doing so here. In general, there's no way to know whether a constant expression will be part of a typedef declaration or function declaration until you've finished parsing it (when you're parsing the decl-specifiers in a declaration you don't know whether you're declaring a function or a variable, and the typedef keyword might appear later).

I see. The issue is that the current approach would forbid valid variable declarations such as:

void (*f)(int [([]{return 5;}())]) = 0;

... where lambdas can appear within the array declarators (I believe that's the only syntactic neighborhood that can cause this problem, right?).

I think so, at least until Louis removes the restriction on lambdas in unevaluated operands. Then we have a whole host of new problems:

decltype([]{}()) typedef x; // error, lambda in a typedef
template<typename T> decltype([]{}()) f(); // error, lambda in a function declaration
template<typename T> decltype([]{}()) x; // ok

If we want a forward-looking change which prepares us for that, we should be thinking about how to deal with deferring the check until we get to the end of the declaration and find out whether we declared a function or a typedef.

Well lambda's can't appear in unevaluated operands yet, so your example would be ill-formed? If so, we don't have to worry about them showing up in decl-specifiers?
The only Declarator where they could be well formed is within an array declarator of a variable or a parameter of a function pointer variable (but no where else, i.e typedefs and function declarations), right?

Right. But we should at least keep in mind the upcoming removal of the unevaluated operands restriction. Ideally, we would get some implementation experience with that now, so we can make sure that we standardize a reasonable set of rules.

include/clang/Basic/DiagnosticSemaKinds.td

     "lambda expression in an unevaluated operand">;
   def err_lambda_in_constant_expression : Error<
     "a lambda expression may not appear inside of a constant expression">;
+  def err_lambda_in_template_argument : Error<
+    "a lambda expression may not appear inside of a template argument">;
+  def err_lambda_in_function_signature : Error<
+    "a lambda expression may not appear inside of a function signature">;
   def err_lambda_return_init_list : Error<
     "cannot deduce lambda return type from initializer list">;
   def err_lambda_capture_default_arg : Error<

include/clang/Parse/Parser.h

     MaybeTypeCast,
     IsTypeCast
   };
-
+  enum class ConstantEvaluationContext {
+    Default,
+    InTemplateArgument,
+    InFunctionSignature
+  };
   ExprResult ParseExpression(TypeCastState isTypeCast = NotTypeCast);
-  ExprResult ParseConstantExpression(TypeCastState isTypeCast = NotTypeCast);
+  ExprResult ParseConstantExpression(
+      TypeCastState isTypeCast = NotTypeCast,
+      ConstantEvaluationContext Ctx = ConstantEvaluationContext::Default);
   ExprResult ParseConstraintExpression();
   // Expr that doesn't include commas.
   ExprResult ParseAssignmentExpression(TypeCastState isTypeCast = NotTypeCast);

include/clang/Sema/DeclSpec.h

   /// DeclTypeInfo.back() will be the least closely bound.
   SmallVector<DeclaratorChunk, 8> DeclTypeInfo;
 
+  Declarator *ParentDeclaratorOfParameterDeclarator = nullptr;
+
   /// InvalidType - Set by Sema::GetTypeForDeclarator().
   unsigned InvalidType : 1;
 

   /// \brief If provided, the source location of the ellipsis used to describe
   /// this declarator as a parameter pack.
   SourceLocation EllipsisLoc;
-  
+  llvm::Optional<tok::TokenKind> PrecedingTok;
   friend struct DeclaratorChunk;
 
 public:
-  Declarator(const DeclSpec &ds, TheContext C)
+  Declarator(const DeclSpec &ds, TheContext C, Declarator *FunD = nullptr)
       : DS(ds), Range(ds.getSourceRange()), Context(C),
+        ParentDeclaratorOfParameterDeclarator(FunD),
         InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error),
         GroupingParens(false), FunctionDefinition(FDK_Declaration),
         Redeclaration(false), Extension(false), ObjCIvar(false),

   /// declared with.
   const DeclSpec &getDeclSpec() const { return DS; }
 
+  const Declarator *getParentDeclarator() const {
+    return ParentDeclaratorOfParameterDeclarator;
+  }
+  void setFunctionPtrOperatorToken(tok::TokenKind Kind) {
+    PrecedingTok = Kind;
+  }
+  
+  bool isFunctionPtrOrRef() const {
+    return PrecedingTok.hasValue();
+  }
   /// getMutableDeclSpec - Return a non-const version of the DeclSpec.  This
   /// should be used with extreme care: declspecs can often be shared between
   /// multiple declarators, so mutating the DeclSpec affects all of the

include/clang/Sema/Sema.h

     /// cases in a switch statement).
     ConstantEvaluated,
 
+    /// \brief Like ConstantEvaluated above, except that the compile-time
+    /// evaluation is occuring within a template argument context. This
+    /// distinction is useful because certain expressions (lambda expressions,
+    /// even immediately invoked ones) are forbidden in such contexts.
+    ConstantEvaluatedInTemplateArgument,
+
+    /// \brief Like ConstantEvaluated above, except that the compile-time
+    /// evaluation is occuring within a function signature. This
+    /// distinction is useful because certain expressions (lambda expressions,
+    /// even immediately invoked ones) are forbidden in such contexts.
+    ConstantEvaluatedInFunctionSignature,
+
     /// \brief The current expression is potentially evaluated at run time,
     /// which means that code may be generated to evaluate the value of the
     /// expression at run time.

       return Context == Unevaluated || Context == UnevaluatedAbstract ||
              Context == UnevaluatedList;
     }
+    bool isConstantEvaluated() const {
+      switch (Context) {
+        case ConstantEvaluated:
+        case ConstantEvaluatedInTemplateArgument:
+        case ConstantEvaluatedInFunctionSignature:
+          return true;
+        default:
+          return false;
+      }
+      llvm_unreachable("all control flow handled within switch");
+    }
   };
 
   /// A stack of expression evaluation contexts.

lib/Parse/ParseDecl.cpp

   // '&&' -> rvalue reference
   SourceLocation Loc = ConsumeToken();  // Eat the *, ^, & or &&.
   D.SetRangeEnd(Loc);
-
   if (Kind == tok::star || Kind == tok::caret) {
     // Is a pointer.
     DeclSpec DS(AttrFactory);

 
     bool hadGroupingParens = D.hasGroupingParens();
     D.setGroupingParens(true);
+    auto TokKind = Tok.getKind();
     ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
     // Match the ')'.
     T.consumeClose();

     // An ellipsis cannot be placed outside parentheses.
     if (EllipsisLoc.isValid())
       DiagnoseMisplacedEllipsisInDeclarator(EllipsisLoc, D);
     
+    if (!D.isFunctionDeclarator() &&
+      isPtrOperatorToken(TokKind, getLangOpts(), D.getContext())) {
+      D.setFunctionPtrOperatorToken(TokKind);
+    }
     return;
   }
 

     // Parse the declarator.  This is "PrototypeContext" or 
     // "LambdaExprParameterContext", because we must accept either 
     // 'declarator' or 'abstract-declarator' here.
-    Declarator ParmDeclarator(DS, 
-              D.getContext() == Declarator::LambdaExprContext ?
-                                  Declarator::LambdaExprParameterContext : 
-                                                Declarator::PrototypeContext);
+    Declarator ParmDeclarator(DS,
+                              D.getContext() == Declarator::LambdaExprContext
+                                  ? Declarator::LambdaExprParameterContext
+                                  : Declarator::PrototypeContext,
+                              &D);
     ParseDeclarator(ParmDeclarator);
 
     // Parse GNU attributes, if present.

     // Parse the constant-expression or assignment-expression now (depending
     // on dialect).
     if (getLangOpts().CPlusPlus) {
-      NumElements = ParseConstantExpression();
+      // TODO: The lambda in an alias/typedef/template-argument needs its own
+      // error message.
+      const bool IsWithinFunctionSignature = [&D] {
+        const Declarator *ParentDeclarator = &D;
+        // TODO: Should we check lambda parameters too?
+        const bool IsPrototypeContext = D.getContext() == D.PrototypeContext;
+        if (IsPrototypeContext) {
+          // Climb up all parameters (even those that are parameters of function
+          // ptr parameters) to the parent function declarator.
+          while (auto *PD = ParentDeclarator->getParentDeclarator())
+            ParentDeclarator = PD;
+        }
+        //TODO: Merge these into one conditional?
+        // No lambda expressions permitted in a typedef
+        if (ParentDeclarator->getDeclSpec().getStorageClassSpec() ==
+            DeclSpec::SCS_typedef)
+          return true;
+        // ... or in a type alias
+        if (ParentDeclarator->getContext() == Declarator::AliasDeclContext ||
+            ParentDeclarator->getContext() == Declarator::AliasTemplateContext)
+          return true;
+        // ... or in a template type argument context
+        if (ParentDeclarator->getContext() == Declarator::TemplateTypeArgContext)
+          return true;
+        // ... or in the return type of a function declarator
+        if (ParentDeclarator->isFunctionDeclarator())
+          return true;
+        // ... or in the parameters of a function.
+        return IsPrototypeContext && !ParentDeclarator->isFunctionPtrOrRef();
+      }();
+      NumElements = ParseConstantExpression(
+          NotTypeCast,
+          IsWithinFunctionSignature
+              ? Parser::ConstantEvaluationContext::InFunctionSignature
+              : Parser::ConstantEvaluationContext::Default);
     } else {
       EnterExpressionEvaluationContext Unevaluated(Actions,
                                                    Sema::ConstantEvaluated);

lib/Parse/ParseExpr.cpp

   return ParseRHSOfBinaryExpression(R, prec::Assignment);
 }
 
-
-ExprResult Parser::ParseConstantExpression(TypeCastState isTypeCast) {
+ExprResult Parser::ParseConstantExpression(
+    TypeCastState isTypeCast,
+    ConstantEvaluationContext ConstantEvalContext) {
+  
+  const Sema::ExpressionEvaluationContext EvalCtx =
+    [ConstantEvalContext] {
+    switch (ConstantEvalContext) {
+    case ConstantEvaluationContext::Default:
+      return Sema::ConstantEvaluated;
+    case ConstantEvaluationContext::InFunctionSignature:
+      return Sema::ConstantEvaluatedInFunctionSignature;
+    case ConstantEvaluationContext::InTemplateArgument:
+      return Sema::ConstantEvaluatedInTemplateArgument;
+    }
+    llvm_unreachable("all cases should be handled above");
+  }();
+  
   // C++03 [basic.def.odr]p2:
   //   An expression is potentially evaluated unless it appears where an
   //   integral constant expression is required (see 5.19) [...].
   // C++98 and C++11 have no such rule, but this is only a defect in C++98.
-  EnterExpressionEvaluationContext ConstantEvaluated(Actions,
-                                               Sema::ConstantEvaluated);
-
+  EnterExpressionEvaluationContext ConstantEvaluated(
+      Actions, EvalCtx);
   ExprResult LHS(ParseCastExpression(false, false, isTypeCast));
   ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::Conditional));
   return Actions.ActOnConstantExpression(Res);

lib/Parse/ParseTemplate.cpp

     //   end of the template-parameter-list rather than a greater-than
     //   operator.
     GreaterThanIsOperatorScope G(GreaterThanIsOperator, false);
-    EnterExpressionEvaluationContext ConstantEvaluated(Actions,
-                                                       Sema::ConstantEvaluated);
+    EnterExpressionEvaluationContext ConstantEvaluated(
+        Actions, Sema::ConstantEvaluatedInTemplateArgument);
 
     DefaultArg = Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
     if (DefaultArg.isInvalid())

   
   // Parse a non-type template argument. 
   SourceLocation Loc = Tok.getLocation();
-  ExprResult ExprArg = ParseConstantExpression(MaybeTypeCast);
+  ExprResult ExprArg = ParseConstantExpression(
+      MaybeTypeCast, ConstantEvaluationContext::InTemplateArgument);
   if (ExprArg.isInvalid() || !ExprArg.get())
     return ParsedTemplateArgument();
 

lib/Sema/SemaExpr.cpp

   unsigned NumTypos = Rec.NumTypos;
 
   if (!Rec.Lambdas.empty()) {
-    if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) {
-      unsigned D;
+    if (Rec.isUnevaluated() || Rec.isConstantEvaluated()) {
+      unsigned D = 0;
       if (Rec.isUnevaluated()) {
         // C++11 [expr.prim.lambda]p2:
         //   A lambda-expression shall not appear in an unevaluated operand
         //   (Clause 5).
         D = diag::err_lambda_unevaluated_operand;
-      } else {
-        // C++1y [expr.const]p2:
-        //   A conditional-expression e is a core constant expression unless the
-        //   evaluation of e, following the rules of the abstract machine, would
-        //   evaluate [...] a lambda-expression.
-        D = diag::err_lambda_in_constant_expression;
+      } else {   
+        // C++1z allows lambda expressions in constant expressions that are not
+        // within template arguments or function signatures.
+        if (getLangOpts().CPlusPlus1z) {
+          if (Rec.Context == Sema::ConstantEvaluatedInFunctionSignature) 
+            D = diag::err_lambda_in_function_signature;
+          else if (Rec.Context == Sema::ConstantEvaluatedInTemplateArgument)
+            D = diag::err_lambda_in_template_argument;
+        } else {
+          // C++14 [expr.const]p2:
+          //   A conditional-expression e is a core constant expression unless
+          //   the
+          //   evaluation of e, following the rules of the abstract machine,
+          //   would
+          //   evaluate [...] a lambda-expression.
+          D = diag::err_lambda_in_constant_expression;
+        }
       }
 
       // C++1z allows lambda expressions as core constant expressions.

       // are part of function-signatures.  Be mindful that P0315 (Lambdas in
       // unevaluated contexts) might lift some of these restrictions in a 
       // future version.
-      if (Rec.Context != ConstantEvaluated || !getLangOpts().CPlusPlus1z)
+      if (D) {
         for (const auto *L : Rec.Lambdas)
           Diag(L->getLocStart(), D);
+      }
     } else {
       // Mark the capture expressions odr-used. This was deferred
       // during lambda expression creation.

   // temporaries that we may have created as part of the evaluation of
   // the expression in that context: they aren't relevant because they
   // will never be constructed.
-  if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) {
+  if (Rec.isUnevaluated() || Rec.isConstantEvaluated()) {
     ExprCleanupObjects.erase(ExprCleanupObjects.begin() + Rec.NumCleanupObjects,
                              ExprCleanupObjects.end());
     Cleanup = Rec.ParentCleanup;

 
     case Sema::UnevaluatedList:
     case Sema::ConstantEvaluated:
+    case Sema::ConstantEvaluatedInTemplateArgument:
+    case Sema::ConstantEvaluatedInFunctionSignature:
     case Sema::PotentiallyEvaluated:
       // Expressions in this context could be evaluated.
       return true;

       return false;
 
     case Sema::ConstantEvaluated:
+    case Sema::ConstantEvaluatedInTemplateArgument:
+    case Sema::ConstantEvaluatedInFunctionSignature:
     case Sema::PotentiallyEvaluated:
       return true;
 

     break;
 
   case ConstantEvaluated:
+  case ConstantEvaluatedInTemplateArgument:
+  case ConstantEvaluatedInFunctionSignature:
+
     // Relevant diagnostics should be produced by constant evaluation.
     break;
 

lib/Sema/SemaExprMember.cpp

 
   case Sema::DiscardedStatement:
   case Sema::ConstantEvaluated:
+  case Sema::ConstantEvaluatedInFunctionSignature:
+  case Sema::ConstantEvaluatedInTemplateArgument:
   case Sema::PotentiallyEvaluated:
   case Sema::PotentiallyEvaluatedIfUsed:
     break;

lib/Sema/SemaLambda.cpp

     //   evaluation of e, following the rules of the abstract machine, would
     //   evaluate [...] a lambda-expression.
     //
-    // This is technically incorrect, there are some constant evaluated contexts
-    // where this should be allowed.  We should probably fix this when DR1607 is
-    // ratified, it lays out the exact set of conditions where we shouldn't
-    // allow a lambda-expression.
+    // In C++1z, lambda-expressions are allowed in certain contexts - which
+    // is handled when the expression evaluation context is popped off.
     case ConstantEvaluated:
+    case ConstantEvaluatedInFunctionSignature:
+    case ConstantEvaluatedInTemplateArgument:
+
       // We don't actually diagnose this case immediately, because we
       // could be within a context where we might find out later that
       // the expression is potentially evaluated (e.g., for typeid).

lib/Sema/SemaTemplate.cpp

   for (unsigned i = 0, e = Param->getDepth(); i != e; ++i)
     TemplateArgLists.addOuterTemplateArguments(None);
 
-  EnterExpressionEvaluationContext ConstantEvaluated(SemaRef,
-                                                     Sema::ConstantEvaluated);
+  EnterExpressionEvaluationContext ConstantEvaluated(
+      SemaRef, Sema::ConstantEvaluatedInTemplateArgument);
   return SemaRef.SubstExpr(Param->getDefaultArgument(), TemplateArgLists);
 }
 

 
   // The initialization of the parameter from the argument is
   // a constant-evaluated context.
-  EnterExpressionEvaluationContext ConstantEvaluated(*this,
-                                                     Sema::ConstantEvaluated);
+  EnterExpressionEvaluationContext ConstantEvaluated(
+      *this, Sema::ConstantEvaluatedInTemplateArgument);
 
   if (getLangOpts().CPlusPlus1z) {
     // C++1z [temp.arg.nontype]p1:

lib/Sema/SemaTemplateInstantiateDecl.cpp

     Param->setInvalidDecl();
 
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
-    EnterExpressionEvaluationContext ConstantEvaluated(SemaRef,
-                                                       Sema::ConstantEvaluated);
+    EnterExpressionEvaluationContext ConstantEvaluated(
+        SemaRef, Sema::ConstantEvaluatedInTemplateArgument);
     ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
     if (!Value.isInvalid())
       Param->setDefaultArgument(Value.get());

lib/Sema/TreeTransform.h

   case TemplateArgument::Expression: {
     // Template argument expressions are constant expressions.
     EnterExpressionEvaluationContext Unevaluated(
-        getSema(), Uneval ? Sema::Unevaluated : Sema::ConstantEvaluated);
+        getSema(),
+        Uneval ? Sema::Unevaluated : Sema::ConstantEvaluatedInTemplateArgument);
 
     Expr *InputExpr = Input.getSourceExpression();
     if (!InputExpr) InputExpr = Input.getArgument().getAsExpr();

test/SemaCXX/cxx1z-constexpr-lambdas.cpp

 
 } // end ns1_simple_lambda
 
+namespace test_forbidden_lambda_expressions {
+
+template<int N = []{ return 5; }()> struct X { }; //expected-error{{lambda expression may not appear}}
+X<[]{return 10; }()> x; //expected-error{{lambda expression may not appear}}
+void f(int arr[([] { return 5; }())]); //expected-error{{lambda expression may not appear}}
+// FIXME: Should this be ok?
+auto L = [](int arr[([] { return 5; }())]) { }; // OK????
+
+// These should be allowed:
+struct A {
+  int : ([] { return 5; }());
+};
+
+int arr[([] { return 5; }())];
+enum { E = [] { return 5; }() };
+static_assert([]{return 5; }() == 5);
+int *ip = new int[([] { return 5; })()];
+
+int test_case(int x) {
+  switch(x) {
+    case [] { return 5; }(): //OK
+      break;
+    case [] (auto a) { return a; }(6): //expected-note{{previous}}
+      break;
+    case 6:  //expected-error{{duplicate}}
+      break;
+  }
+  return x;
+}
+namespace ns2 {
+int (*f)(int a[([] { return 5; }())]);
+int fun(int a[([] { return 5; }())]);  //expected-error{{lambda expression}}
+int fun2(void (*)(int a[([] { return 5; }())])); //expected-error{{lambda expression}}
+int (*fun2p)(void f(int a[([] { return 5; }())]));
+
+int (*g(int))[([] { return 5; })()];  //expected-error{{lambda expression}}
+int *(fun3)(int a[([] { return 5; }())]); //expected-error{{lambda expression}}
+
+
+int *(&fun3r)(int a[([] { return 5; }())]) = ([] () -> auto& { int *fv(int *); return fv; })();
+
+int (*g2(int))[([] { return 5; })()]; //expected-error{{lambda expression}}
+
+int (*(*g3)(int))[([] { return 5; })()];
+template<class T> struct X { };
+X<int (*)(int a[([] { return 5; }())])> x; //expected-error{{lambda expression}}
+} //end ns2
+
+} // end ns forbidden_lambda_expressions
+
 namespace ns1_unimplemented {
 namespace ns1_captures {
 constexpr auto f(int i) {