Why does GCC think that the definition of a constexpr static data member must be marked constexpr?

Question

[C++14: 7.1.5/1]: The constexpr specifier shall be applied only to the definition of a variable or variable template, the declaration of a function or function template, or the declaration of a static data member of a literal type (3.9). If any declaration of a function, function template, or variable template has a constexpr specifier, then all its declarations shall contain the constexpr specifier. [..]

Notice that the second sentence does not mention "a static data member" the way the first sentence does, so there is no requirement in this passage that all declarations (and here I'm considering a defining declaration specifically) of a constexpr static data member have the constexpr specifier.

I can't find a rule elsewhere to mandate this, either.

Why, then, does GCC reject the following program?

#include <chrono>

using namespace std::chrono_literals;

#define DUR 1000ms

struct T
{
   static constexpr auto dur_1 = DUR;
};

decltype(T::dur_1) T::dur_1;

// main.cpp:12:23: error: 'constexpr' needed for in-class initialization of static data member 'const std::chrono::duration<long int, std::ratio<1l, 1000l> T::dur_1' of non-integral type [-fpermissive] 
// decltype(T::dur_1) T::dur_1;
//                       ^

Answer 1

This looks underspecified to me, I don't see an explicit requirement but we can see why it is an issue from defect report 699: Must constexpr member functions be defined in the class member-specification? which although dealing with constexpr member functions says the following (emphasis mine):

If the prohibition were relaxed to allow separate declaration and definition of constexpr member functions, some questions would need to be answered, such as whether the constexpr specifier must appear on both declaration and definition (the inline specifier need not). If it can be omitted in one or the other, there's a usability issue regarding the fact that constexpr implies const; the const qualifier would need to be specified explicitly in the declaration in which constexpr was omitted.

Although in this case adding const does not solve the problem although in a simpler cases it does seem to solve the issue. We can see in a simpler case both clang and gcc require either const or constexpr:

struct T
{
   static constexpr int blah = 1 ;
};

const int T::blah ;

Update

This gcc bug report: Bogus "error: redeclaration ... differs in ‘constexpr’" has the following quote from Richard Smith:

There is no rule requiring successive declarations of variables to agree in 'constexpr'ness (this rule only applies to functions).

So this looks like a gcc bug, although it still seems like it could use some clarity in the standard.

Answer 2

A constexpr static data member has to be initialized in class according to 7.1.5 (9). This is the definition of the member. Because of the ODR no other definition is allowed, so T::dur_1 could only be a declaration. But there is no rule allowing declaration of const static data members outside the class body, so this declaration isn't allowed.

GCC support this as an extension only if constexpr is used consistently.

Or I'm wrong and it's a bug ;)

FWIW: clang accepts this code without a warning.

Answer 3

My previous answer thought that the problem with the code was that the std::chrono_literals objects were not valid as constexps, but as pointed out by Lightspeed, this is not the case.

I did a little more research and determined that the problem line with your code is your struct t: specifically this line:

static constexp auto ...

There is another answer on SO about this here

To explicitly point out why this is your issue (as the comment indicates this is not immediately obvious):

Any expression labeled constexp is to be determined at compile-time. This much you know already. When you try and instantiate with the decltype(T::dur_1) T:dur_1 expression, in your eyes you are providing the proper credentials to the chrono literal constructor (which is constexp). The issue is that the type is not explicitly defined as you seem to think it is from your pre-processor definition of the DUR replacement of 1000ms.

Try the following:

template <class T>
struct foo {
    static constexpr auto dur_1 = DUR;
    typedef decltype(DUR) milliseconds;
}

template <class T>
constexp milliseconds foo<T>::milliseconds foo<T>::DUR; 

By removing the inability of the GCC compiler to determine the auto type at compile time through the explicit definition, you should solve your problem.

This is why the original link was given. GCC is incorrectly unable to determine the auto-typing at compile time.