mjhjmtu

Look at this snippet:

int a;
extern int b;
auto b = a;

Is it well-formed? Clang successfully compiles it, but GCC and MSVC don't.

(This issue has come up when I answered How to declare and define a static member with deduced type?)

Clang, GCC, MSVC. (This answer previous stated that all 3 compilers would refuse to build it, but that was incorrect.)

dcl.spec.auto does not address the compatibility of multiple declarations of the same variable when mixing the auto type specifier with other type specifiers. However, it addresses it for function return types:

auto f();
auto f() return 42; // return type is int
auto f(); // OK
int f(); // error, cannot be overloaded with auto f()
decltype(auto) f(); // error, auto and decltype(auto) don't match

So my intuition is that this is an oversight in the standard and the behavior is currently unspecified, but if/when it gets specified, there would be precedent to make it illegal. (On the other hand, variables can't be overloaded, so who knows.)

Update clang is correct

I asked this question on twitter and the response I received from Richard Smith was as follows:

Not a defect, it's intentional that this restriction applies only to deduced return types and not to variable types. For variables, it's just a convenience shorthand, but return type deduction affects something more fundamental about functions (and especially function templates).

So the logic is that this is allowed by [dcl.spec.auto] and to restrict this for deduced return types [dcl.spec.auto]p11 was added otherwise there is no restriction and therefore this is not restricted for the variables case.

Original

Currently [dcl.spec.auto] does not seem to cover this case explictly but it does say in [dcl.spec.auto]p5:

A program that uses auto or decltype(auto) in a context not explicitly allowed in this subclause is ill-formed.

and we can see it makes a similar case for functions ill-formed in [dcl.spec.auto]p11:

Redeclarations or specializations of a function or function template
with a declared return type that uses a placeholder type shall also
use that placeholder, not a deduced type. Similarly, redeclarations or
specializations of a function or function template with a declared
return type that does not use a placeholder type shall not use a
placeholder. [ Example:

auto f();
auto f() return 42; // return type is int
auto f(); // OK
int f(); // error, cannot be overloaded with auto f()

....

So although this could use clarification as currently worded it feels like gcc is correct and this is ill-formed.