llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang Author: Guillot Tony (to268) <details> <summary>Changes</summary> This PR is documenting the behavior of Clang towards underspecified object declarations in C23 as advised by @<!-- -->AaronBallman. --- Full diff: https://github.com/llvm/llvm-project/pull/140911.diff 4 Files Affected: - (modified) clang/docs/LanguageExtensions.rst (+48) - (modified) clang/docs/ReleaseNotes.rst (+2) - (added) clang/test/C/C23/n3006.c (+113) - (modified) clang/www/c_status.html (+1-1) ``````````diff diff --git a/clang/docs/LanguageExtensions.rst b/clang/docs/LanguageExtensions.rst index a40dd4d1a1673..aa76daf0ea459 100644 --- a/clang/docs/LanguageExtensions.rst +++ b/clang/docs/LanguageExtensions.rst @@ -6454,3 +6454,51 @@ qualifications. Note, Clang does not allow an ``_Atomic`` function type because of explicit constraints against atomically qualified (arrays and) function types. + + +Underspecified object declarations in C +======================================= + +In C23 (N3006), when an object is declared inside of another object and that +only exists in the scope of the declaration of the outer object. Clang allows +underspecified object declarations for structs, unions and enums when valid. + +.. code-block:: c + + auto s1 = (struct S1 { int x, y; }){ 1, 2 }; + auto u1 = (union U1 { int a; double b; }){ .a = 34 }; + auto e1 = (enum E1 { FOO, BAR }){ BAR }; + +Note, The ``constexpr`` keyword and getting a struct member that is +underspecified is also allowed. + +.. code-block:: c + + constexpr auto cs1 = (struct S1 { int x, y; }){ 1, 2 }; + constexpr auto cu1 = (union U1 { int a; double b; }){ .a = 34 }; + constexpr auto ce1 = (enum E1 { FOO, BAR }){ BAR }; + int i1 = (struct T { int a, b; }){0, 1}.a; + constexpr int ci2 = (struct T2 { int a, b; }){0, 1}.a; + +Moreover, some unusual cases are also allowed as described bellow. + +.. code-block:: c + + constexpr struct S { int a, b; } y = { 0 }; + constexpr typeof(struct s *) x = 0; + auto so = sizeof(struct S {}); + auto s = ({struct T { int x; } s = {}; s.x; }); + constexpr int (*fp)(struct X { int x; } val) = 0; + auto v = (void (*)(int y))0; + + constexpr struct { + int a; + } si = {}; + + auto z = ({ + int a = 12; + struct {} s; + a; + }); + +All other cases are prohibited by Clang. diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 537f29521fb7f..c8de10f951933 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -273,6 +273,8 @@ C23 Feature Support be completed). - Fixed a failed assertion with an invalid parameter to the ``#embed`` directive. Fixes #GH126940. +- Documented `WG14 N3006 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3006.htm>`_ + which clarified how Clang is handling underspecified object declarations. C11 Feature Support ^^^^^^^^^^^^^^^^^^^ diff --git a/clang/test/C/C23/n3006.c b/clang/test/C/C23/n3006.c new file mode 100644 index 0000000000000..033e0b407e7f5 --- /dev/null +++ b/clang/test/C/C23/n3006.c @@ -0,0 +1,113 @@ +// RUN: %clang_cc1 -std=c23 -verify %s + +/* WG14 N3006: Yes + * Underspecified object declarations + */ + +void struct_test(void) { + struct S1 { int x, y; }; // expected-note {{field 'x' has type 'int' here}} + + auto normal_struct = (struct S1){ 1, 2 }; + auto normal_struct2 = (struct S1) { .x = 1, .y = 2 }; + auto underspecified_struct = (struct S2 { int x, y; }){ 1, 2 }; + auto underspecified_struct_redef = (struct S1 { char x, y; }){ 'A', 'B'}; // expected-error {{type 'struct S1' has incompatible definitions}} \ + expected-error {{cannot use 'auto' with array in C}} \ + expected-note {{field 'x' has type 'char' here}} + auto underspecified_empty_struct = (struct S3 { }){ }; + auto zero_init_struct = (struct S4 { int x; }){ 0 }; + int field_struct = (struct S5 { int y; }){ 0 }.y; +} + +void union_test(void) { + union U1 { int a; double b; }; // expected-note {{field 'a' has type 'int' here}} + + auto normal_union_int = (union U1){ .a = 12 }; + auto normal_union_double = (union U1){ .b = 2.4 }; + auto underspecified_union = (union U2 { int a; double b; }){ .a = 34 }; + auto underspecified_union_redef = (union U1 { char a; double b; }){ .a = 'A' }; // expected-error {{type 'union U1' has incompatible definitions}} \ + expected-error {{cannot use 'auto' with array in C}} \ + expected-note {{field 'a' has type 'char' here}} + auto underspecified_empty_union = (union U3 { }){ }; +} + +void enum_test(void) { + enum E1 { FOO, BAR }; // expected-note {{enumerator 'BAR' with value 1 here}} + + auto normal_enum_foo = (enum E1){ FOO }; + auto normal_enum_bar = (enum E1){ BAR }; + auto underspecified_enum = (enum E2 { BAZ, QUX }){ BAZ }; + auto underspecified_enum_redef = (enum E1 { ONE, TWO }){ ONE }; // expected-error {{type 'enum E1' has incompatible definitions}} \ + expected-error {{cannot use 'auto' with array in C}} \ + expected-note {{enumerator 'ONE' with value 0 here}} + auto underspecified_empty_enum = (enum E3 { }){ }; // expected-error {{use of empty enum}} + auto underspecified_undeclared_enum = (enum E4){ FOO }; // expected-error {{variable has incomplete type 'enum E4'}} \ + expected-note {{forward declaration of 'enum E4'}} +} + +void constexpr_test(void) { + constexpr auto ce_struct = (struct S1){ 1, 2 }; // expected-error {{variable has incomplete type 'struct S1'}} \ + expected-note {{forward declaration of 'struct S1'}} + constexpr auto ce_struct_zero_init = (struct S2 { int x; }){ 0 }; + constexpr int ce_struct_field = (struct S3 { int y; }){ 0 }.y; + constexpr auto ce_union = (union U1){ .a = 12 }; // expected-error {{variable has incomplete type 'union U1'}} \ + expected-note {{forward declaration of 'union U1'}} + + constexpr auto ce_enum = (enum E1 { BAZ, QUX }){ BAZ }; + constexpr auto ce_empty_enum = (enum E2){ FOO }; // expected-error {{use of undeclared identifier 'FOO'}} +} + +void self_reference_test(void) { + constexpr int i = i; // expected-error {{constexpr variable 'i' must be initialized by a constant expression}} \ + expected-note {{read of object outside its lifetime is not allowed in a constant expression}} + auto j = j; // expected-error {{variable 'j' declared with deduced type 'auto' cannot appear in its own initializer}} +} + +void redefinition_test(void) { + const struct S { int x; } s; // expected-warning {{default initialization of an object of type 'const struct S' leaves the object uninitialized}} \ + expected-note {{previous definition is here}} + constexpr struct S s = {0}; // expected-error {{redefinition of 's'}} +} + +void declaring_an_underspecified_defied_object_test(void) { + struct S { int x, y; }; + constexpr int i = (struct T { int a, b; }){0, 1}.a; + + struct T t = { 1, 2 }; +} + +void constexpr_complience_test(void) { + int x = (struct Foo { int x; }){ 0 }.x; + constexpr int y = (struct Bar { int x; }){ 0 }.x; +} + +void builtin_functions_test(void) { + constexpr typeof(struct s *) x = 0; + auto so = sizeof(struct S {}); + auto to = typeof(struct S {}); // expected-error {{expected expression}} +} + +void misc_test(void) { + constexpr struct S { int a, b; } y = { 0 }; + constexpr int a = 0, b = 0; + auto c = (struct T { int x, y; }){0, 0}; + auto s2 = ({struct T { int x; } s = {}; s.x; }); + auto s3 = ((struct {}){},0); // expected-warning {{left operand of comma operator has no effect}} + constexpr int (*fp)(struct X { int x; } val) = 0; + auto v = (void (*)(int y))0; +} + +void misc_struct_test(void) { + constexpr struct { + int a; + } a = {}; + + constexpr struct { + int b; + } b = (struct S { int x; }){ 0 }; // expected-error-re {{initializing 'const struct (unnamed struct at {{.*}}n3006.c:104:13)' with an expression of incompatible type 'struct S'}} + + auto z = ({ + int a = 12; + struct {} s; + a; + }); +} diff --git a/clang/www/c_status.html b/clang/www/c_status.html index e47466e3273f2..dcff2fc2b1a3e 100644 --- a/clang/www/c_status.html +++ b/clang/www/c_status.html @@ -864,7 +864,7 @@ <h2 id="c2x">C23 implementation status</h2> <tr> <td>Underspecified object definitions</td> <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3006.htm";>N3006</a></td> - <td class="none" align="center">No</td> + <td class="unreleased" align="center">Yes</td> </tr> <tr> <td>Type inference for object declarations</td> `````````` </details> https://github.com/llvm/llvm-project/pull/140911 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
