>
>
> From: "James Dennett via cfe-dev" <cfe-dev@lists.llvm.org>
> To: "Akira Hatanaka" <ahatanak@gmail.com>
> Cc: "Richard Smith" <richard@metafoo.co.uk>, "Clang Dev" <
cfe-dev@lists.llvm.org>
> Sent: Wednesday, May 25, 2016 6:37:46 PM
> Subject: Re: [cfe-dev] c++ question: can lambda be used in VLA?
>
> I wasn't requesting that clang accept lambda expressions used for array
bounds but was asking whether it was valid in c++. Is this something that
is open to interpretation because it's not covered by the standard?
>
> FYI, this isn't something that I made up. It was in a code a user wrote.
>
>
> It's covered by the standard, and as Clang's error message says,
lambdas are not allowed in constant expressions in C++11 or C++14.
>
>
> Yes, the c++ standard gives a list of subexpressions that are not
allowed in constant expressions and lambda expression is one of them.
>
> This doesn't seem to apply to C99's extension for variable length
arrays because array sizes are not required to be constant expressions.
>
>
> I was replying to you saying that you were "asking whether it was valid
in C++", and whether "it's not covered by the standard".
>
> C99 doesn't have lambdas, so it doesn't allow this. C++ doesn't have
VLAs, so it doesn't allow it.
>
> The de facto language accepted by Clang doesn't accept it, as you
already noted.
>
> There's no specification that tells us what the "right thing to do" is
here. We could extend Clang to support this non-standard combination of
C99 with C++11, and it might even make it a little more consistent, but if
it adds any implementation complexity then it may not be worthwhile to
support a corner case that's not allowed by any language standard.
> What did the most recent wording for C++ ARBs say about this issue?The latest version I could find is here:
Working Draft, Technical Specification — Array Extensions
The changes to 8.3.4 Arrays [dcl.array] change the argument from a
constant-expression_opt to an expression_opt:Working Draft, Technical Specification — Array Extensions
I think the Array TS was killed in Jacksonville due to lack of interest,
but the interaction between these features seems straightforward to me.
When the C++ language extension for VLAs is turned on, we shouldn't treat
the array argument as a constant-expression.This isn't quite that simple... We do not have a C++ language extension
for VLAs that can be turned on and off in the way you seem to expect. What
we have is an extension warning that can be disabled or turned into an
error. Following our usual philosophy for warning flags, it's not
reasonable for -Wno-vla to affect how we parse an array bound.
If it's not desirable to change the how we parse an array bound, I'll just
add a flag to ExpressionEvaluationContextRecord that indicates whether an
array bound in a BlockContext is being parsed.