No array bounds check when using auto

Question

When having this code compiling with -Warray-bounds. I get a warning when declaring array2 array index 3 is past the end of the array (which contains 3 elements). But not when declaring array1 even though it has to be the same type thus carrying the same size information. Is this a bug in clang?

enum class Format : int {
  Off = 55,
  FormatA = 66,
  FormatB = 77,
};

inline Format (&AllFormats())[3] {
  static Format values[] = {
    Format::Off,
    Format::FormatA,
    Format::FormatB
  };
  return values;
}

int main()
{
    auto array1 = AllFormats();    
    auto v3 = array1[3];

    Format (&array2)[3] = AllFormats();    
    v3 = array2[3];
}

Answer 1

even though it has to be the same type

You’d think that. But if you check, you’ll find that they actually don’t have the same type:

std::cout << typeid(array1).name() << "\n";
std::cout << typeid(array2).name() << "\n";

P6Format
A3_6Format

Oops. The array returned by AllFormats decays to a pointer when assigned to an auto variable because that’s how the type deduction rules for auto work. Compare:

int& foo() {
    static int x = 42;
    return x;
}

auto x = foo(); // Type of `x` is `int`, not `int&`.

To prevent this, declare array1 as auto& or auto&&.

Answer 2

But not at line 16 even though it has to be the same type

Assuming by it you refer to auto array1 = AllFormats(), then it doesn't have the same type. auto is never deduced to be a reference, so array1 is not a reference. It is a non-reference, and is deduced to be the decayed result, i.e. a pointer to Format.

As the pointer type doesn't carry information about the size of the pointed array, the compiler wasn't able to prove that the subscript operator overflows the array.

To declare a reference, you can use either:

auto&          array1 = AllFormats(); // 1.
auto&&         array1 = AllFormats(); // 2.
decltype(auto) array1 = AllFormats(); // 3.

1. Declares explicitly an lvalue reference.
2. Declares a universal reference, which collapses into an lvalue reference, because AllFormats returns an lvalue reference. It would be an rvalue reference if AllFormats returned Format&&.
3. auto type deduction uses different rules from decltype deduction. One key difference is that auto is never a reference, while decltype(E); may be a reference, depending on the expression E. decltype(auto) var = E allows a declaration using the decltype rules as if decltype(E) was used.