Allow use of lambda expressions in array bounds

[ahatanak]

Summary

clang currently errors out when a lambda expression is used to compute the size of an array even though clang supports variable-length arrays as a C99 extension. For example,

$ cat vla1.cpp

int foo3();

struct S1 {
  virtual ~S1();
};

struct S2 : S1 {
};

void foo(S1 *s1) {
  unsigned char a1[([](int a) {return a; })(1)];
  unsigned char a2[foo3()]; // This is OK.
  unsigned char a3[!dynamic_cast<S2 *>(s1) + 1];  // This is OK.
}

$ clang++ vla1.cpp -c -std=c++11
vla1.cpp:11:21: error: a lambda expression may not appear inside of a constant expression

unsigned char a1[([](int a) {return a; })(1)];
                  ^

1 error generated.

To handle VLAs in a more consistent way, this patch makes changes to allow lambda expressions to be used for array bounds if it is in a BlockContext.

[rsmith]

lib/Sema/SemaExpr.cpp

12825

This isn't correct; you still need to produce the diagnostic even if we're in an array bound, but it should be an ExtWarn controlled by -Wvla. A case like

void f() {
  int arr[ true ? 1 : []{return 0}() ];
}

is ill-formed in standard C++, but as we can evaluate the array bound as a constant, Clang will no longer diagnose it with this change in place.

12834–12839

If you accept lambdas inside VLA bounds, you need to do this step for them.

12848–12853

This also looks wrong for your lambda-in-VLA-bound case.

Perhaps the best thing to do is to check whether we have a VLA *before* we pop the ExpressionEvaluationContextRecord, and if so, convert the context from ConstantEvaluated to Evaluated.

[ahatanak]

Sorry for my late reply.

lib/Sema/SemaExpr.cpp

12825

Is this ill-formed too in standard c++?

int a[true ? 2 : !dynamic_cast<S2*>(s1) + 1];

clang doesn't warn or error out when compiling the expression above.

12848–12853

It seems like we won't be able to warn about lambdas in constant expressions at all if we change the context before popping ExpressionEvaluationContextRecord, so there would be no warnings for your example code (ternary expression used for array bound). Is that your intention?

include/clang/Parse/Parser.h

public:
   /// TypeCastState - State whether an expression is or may be a type cast.
   enum TypeCastState {
     NotTypeCast = 0,
     MaybeTypeCast,
     IsTypeCast
   };
 
   ExprResult ParseExpression(TypeCastState isTypeCast = NotTypeCast);
-  ExprResult ParseConstantExpression(TypeCastState isTypeCast = NotTypeCast);
+  ExprResult ParseConstantExpression(TypeCastState isTypeCast = NotTypeCast,
+                                     bool IsArrayBound = false);
   ExprResult ParseConstraintExpression();
   // Expr that doesn't include commas.
   ExprResult ParseAssignmentExpression(TypeCastState isTypeCast = NotTypeCast);
 
   ExprResult ParseMSAsmIdentifier(llvm::SmallVectorImpl<Token> &LineToks,
                                   unsigned &NumLineToksConsumed,
                                   void *Info,
                                   bool IsUnevaluated);

include/clang/Sema/Sema.h

struct ExpressionEvaluationContextRecord {
     /// is indeed an unevaluated context.
     SmallVector<LambdaExpr *, 2> Lambdas;
 
     /// \brief The declaration that provides context for lambda expressions
     /// and block literals if the normal declaration context does not
     /// suffice, e.g., in a default function argument.
     Decl *ManglingContextDecl;
 
+    /// \brief Whether an array bound in a BlockContext is being parsed.
+    bool IsArrayBound;
+
     /// \brief The context information used to mangle lambda expressions
     /// and block literals within this context.
     ///
     /// This mangling information is allocated lazily, since most contexts
     /// do not have lambda expressions or block literals.
     IntrusiveRefCntPtr<MangleNumberingContext> MangleNumbering;
 
     /// \brief If we are processing a decltype type, a set of call expressions
     /// for which we have deferred checking the completeness of the return type.
     SmallVector<CallExpr *, 8> DelayedDecltypeCalls;
 
     /// \brief If we are processing a decltype type, a set of temporary binding
     /// expressions for which we have deferred checking the destructor.
     SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds;
 
     ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
                                       unsigned NumCleanupObjects,
                                       bool ParentNeedsCleanups,
                                       Decl *ManglingContextDecl,
-                                      bool IsDecltype)
+                                      bool IsDecltype, bool IsArrayBound)
       : Context(Context), ParentNeedsCleanups(ParentNeedsCleanups),
         IsDecltype(IsDecltype), NumCleanupObjects(NumCleanupObjects),
         NumTypos(0),
-        ManglingContextDecl(ManglingContextDecl), MangleNumbering() { }
+        ManglingContextDecl(ManglingContextDecl),
+        IsArrayBound(IsArrayBound), MangleNumbering() {}
 
     /// \brief Retrieve the mangling numbering context, used to consistently
     /// number constructs like lambdas for mangling.
     MangleNumberingContext &getMangleNumberingContext(ASTContext &Ctx);
 
     bool isUnevaluated() const {
       return Context == Unevaluated || Context == UnevaluatedAbstract;
     }
public:
   bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
                                         ObjCMethodDecl *Getter,
                                         SourceLocation Loc);
   void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
                              ArrayRef<Expr *> Args);
 
   void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
                                        Decl *LambdaContextDecl = nullptr,
-                                       bool IsDecltype = false);
+                                       bool IsDecltype = false,
+                                       bool IsArrayBound = false);
   enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl };
   void PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
                                        ReuseLambdaContextDecl_t,
                                        bool IsDecltype = false);
   void PopExpressionEvaluationContext();
 
   void DiscardCleanupsInEvaluationContext();
 

 /// \brief RAII object that enters a new expression evaluation context.
 class EnterExpressionEvaluationContext {
   Sema &Actions;
 
 public:
   EnterExpressionEvaluationContext(Sema &Actions,
                                    Sema::ExpressionEvaluationContext NewContext,
                                    Decl *LambdaContextDecl = nullptr,
-                                   bool IsDecltype = false)
+                                   bool IsDecltype = false,
+                                   bool IsArrayBound = false)
     : Actions(Actions) {
     Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl,
-                                            IsDecltype);
+                                            IsDecltype, IsArrayBound);
   }
   EnterExpressionEvaluationContext(Sema &Actions,
                                    Sema::ExpressionEvaluationContext NewContext,
                                    Sema::ReuseLambdaContextDecl_t,
                                    bool IsDecltype = false)
     : Actions(Actions) {
     Actions.PushExpressionEvaluationContext(NewContext, 
                                             Sema::ReuseLambdaContextDecl,

lib/Parse/ParseDecl.cpp

if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
     // Note, in C89, this production uses the constant-expr production instead
     // of assignment-expr.  The only difference is that assignment-expr allows
     // things like '=' and '*='.  Sema rejects these in C89 mode because they
     // are not i-c-e's, so we don't need to distinguish between the two here.
 
     // Parse the constant-expression or assignment-expression now (depending
     // on dialect).
     if (getLangOpts().CPlusPlus) {
-      NumElements = ParseConstantExpression();
+      NumElements = ParseConstantExpression(
+          Parser::NotTypeCast, D.getContext() == Declarator::BlockContext);
     } else {
       EnterExpressionEvaluationContext Unevaluated(Actions,
                                                    Sema::ConstantEvaluated);
       NumElements =
           Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
     }
   } else {
     if (StaticLoc.isValid()) {

lib/Parse/ParseExpr.cpp

Parser::ParseAssignmentExprWithObjCMessageExprStart(SourceLocation LBracLoc,
   ExprResult R
     = ParseObjCMessageExpressionBody(LBracLoc, SuperLoc,
                                      ReceiverType, ReceiverExpr);
   R = ParsePostfixExpressionSuffix(R);
   return ParseRHSOfBinaryExpression(R, prec::Assignment);
 }
 
 
-ExprResult Parser::ParseConstantExpression(TypeCastState isTypeCast) {
+ExprResult Parser::ParseConstantExpression(TypeCastState isTypeCast,
+                                           bool IsArrayBound) {
   // 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 Unevaluated(Actions,
-                                               Sema::ConstantEvaluated);
+  EnterExpressionEvaluationContext Unevaluated(Actions, Sema::ConstantEvaluated,
+                                               nullptr, false, IsArrayBound);
 
   ExprResult LHS(ParseCastExpression(false, false, isTypeCast));
   ExprResult Res(ParseRHSOfBinaryExpression(LHS, prec::Conditional));
   return Actions.ActOnConstantExpression(Res);
 }
 
 /// \brief Parse a constraint-expression.
 ///

lib/Sema/Sema.cpp

if (getLangOpts().ObjC1)
     NSAPIObj.reset(new NSAPI(Context));
 
   if (getLangOpts().CPlusPlus)
     FieldCollector.reset(new CXXFieldCollector());
 
   // Tell diagnostics how to render things from the AST library.
   Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
 
-  ExprEvalContexts.emplace_back(PotentiallyEvaluated, 0, false, nullptr, false);
+  ExprEvalContexts.emplace_back(PotentiallyEvaluated, 0, false, nullptr, false,
+                                false);
 
   FunctionScopes.push_back(new FunctionScopeInfo(Diags));
 
   // Initilization of data sharing attributes stack for OpenMP
   InitDataSharingAttributesStack();
 }
 
 void Sema::addImplicitTypedef(StringRef Name, QualType T) {

lib/Sema/SemaExpr.cpp

ExprResult Sema::TransformToPotentiallyEvaluated(Expr *E) {
   if (isUnevaluatedContext())
     return E;
   return TransformToPE(*this).TransformExpr(E);
 }
 
 void
 Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
                                       Decl *LambdaContextDecl,
-                                      bool IsDecltype) {
+                                      bool IsDecltype, bool IsArrayBound) {
   ExprEvalContexts.emplace_back(NewContext, ExprCleanupObjects.size(),
                                 ExprNeedsCleanups, LambdaContextDecl,
-                                IsDecltype);
+                                IsDecltype, IsArrayBound);
   ExprNeedsCleanups = false;
   if (!MaybeODRUseExprs.empty())
     std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs);
 }
 
 void
 Sema::PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext,
                                       ReuseLambdaContextDecl_t,
                                       bool IsDecltype) {
   Decl *ClosureContextDecl = ExprEvalContexts.back().ManglingContextDecl;
   PushExpressionEvaluationContext(NewContext, ClosureContextDecl, IsDecltype);
 }
 
 void Sema::PopExpressionEvaluationContext() {
   ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back();
   unsigned NumTypos = Rec.NumTypos;
 
   if (!Rec.Lambdas.empty()) {
     if (Rec.isUnevaluated() || Rec.Context == ConstantEvaluated) {
-      unsigned D;
       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 {
+        for (const auto *L : Rec.Lambdas)
+          Diag(L->getLocStart(), diag::err_lambda_unevaluated_operand);
+      // Don't error out on lambdas used to compute array size in a
+      // BlockContext.
+      } else if (!Rec.IsArrayBound) {
         // 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;
-      }
         for (const auto *L : Rec.Lambdas)
-        Diag(L->getLocStart(), D);
+          Diag(L->getLocStart(), diag::err_lambda_in_constant_expression);
+      }
     } else {
       // Mark the capture expressions odr-used. This was deferred
       // during lambda expression creation.
       for (auto *Lambda : Rec.Lambdas) {
         for (auto *C : Lambda->capture_inits())
           MarkDeclarationsReferencedInExpr(C);
       }
     }
   }
 
   // When are coming out of an unevaluated context, clear out any
   // 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) {
     ExprCleanupObjects.erase(ExprCleanupObjects.begin() + Rec.NumCleanupObjects,
                              ExprCleanupObjects.end());
     ExprNeedsCleanups = Rec.ParentNeedsCleanups;
     CleanupVarDeclMarking();
     std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs);
   // Otherwise, merge the contexts together.
   } else {
     ExprNeedsCleanups |= Rec.ParentNeedsCleanups;
     MaybeODRUseExprs.insert(Rec.SavedMaybeODRUseExprs.begin(),
                             Rec.SavedMaybeODRUseExprs.end());
   }
 
   // Pop the current expression evaluation context off the stack.
   ExprEvalContexts.pop_back();

test/SemaCXX/lambda-expressions.cpp

 
 void foo() {
   const int num = 18;  // expected-note {{'num' declared here}}
   auto outer = []() {
     auto inner = [](S<num> &X) {};  // expected-error {{variable 'num' cannot be implicitly captured in a lambda with no capture-default specified}}
   };
 }
 }
+
+namespace array_bound {
+void foo() {
+  int a0[([](){ return 4; })()];
+  int a2[([](int n){ return n; })(4)];
+}
+
+int a2[([](){ return 4; })()]; // expected-error {{a lambda expression may not appear inside of a constant expression}} expected-error {{variable length array declaration not allowed at file scope}}
+}