Pre-C23 arrays of qualified type shouldn't be considered qualified

[Halalaluyafail3]

The following program demonstrates the issue:

int main(void){
    const int(*p)[2]=0;
    void*q=p;
}

Before C23, const int[2] was not considered a qualified type so this conversion was valid. GCC allows it, Clang incorrectly rejects it. Here is another example that demonstrates the opposite:

int main(void){
    int(*p)[2]=0;
    const int(*q)[2]=p;
}

const int[2] is not a qualified version of int[2] before C23, so this conversion was invalid. GCC rejects it, Clang incorrectly allows it.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (Halalaluyafail3)

The following program demonstrates the issue: ```c int main(void){ const int(*p)[2]=0; void*q=p; } ``` Before C23, `const int[2]` was not considered a qualified type so this conversion was valid. GCC allows it, Clang incorrectly rejects it. Here is another example that demonstrates the opposite: ```c int main(void){ int(*p)[2]=0; const int(*q)[2]=p; } ``` `const int[2]` is not a qualified version of `int[2]` before C23, so this conversion was invalid. GCC rejects it, Clang incorrectly allows it.

[frederick-vs-ja]

This is documented as an "extension", see also 09841d7.

llvm-project/clang/docs/LanguageExtensions.rst

Line 1809 in 7a54353

Array & element qualification (N2607) C23 C89

Perhaps Clang is intendedly non-conforming on this in old modes.

[Halalaluyafail3]

This is documented as an "extension"

Why would extensions be used in options such as -pedantic-errors to give errors that only make sense for later versions?

[AaronBallman]

The first example is diagnosed the same in Clang and GCC, the difference is that it's an ExtWarn diagnostic in Clang and thus -pedantic-errors will reject the code. But either way, both compilers diagnose the loss of the qualifier because that's a security concern. This has been Clang's behavior since at least 3.0: https://godbolt.org/z/7sqT7znKx

You can silence the diagnostic with -Wno-incompatible-pointer-types: https://godbolt.org/z/dEfas1Eha

Neither compiler diagnoses the second example, at least by my testing: https://godbolt.org/z/d7qf6jx17

It's possible we should split the diagnostic so there's an ExtWarn variant and a Warning variant so that -pedantic-errors doesn't catch it, but given how long Clang has had this behavior I think it's low priority.

[Halalaluyafail3]

Neither compiler diagnoses the second example, at least by my testing: https://godbolt.org/z/d7qf6jx17

You're compiling with -std=c23, but this is specifically about pre-C23. Here a link that demonstrates that GCC rejects it: https://godbolt.org/z/xTq4TTePW

[AaronBallman]

Neither compiler diagnoses the second example, at least by my testing: https://godbolt.org/z/d7qf6jx17

You're compiling with -std=c23, but this is specifically about pre-C23. Here a link that demonstrates that GCC rejects it: https://godbolt.org/z/xTq4TTePW

Ah thank you for that, stupid think-o on my part for missing the -std=c23. Yeah, we should have a pedantic diagnostic for that scenario, same as GCC.