[Bug c/115424] New: 'auto' type inference not working when struct declared in rhs, even when the final type is not anonymous

[Bug c/115424] New: 'auto' type inference not working when struct declared in rhs, even when the final type is not anonymous

[malekwryyy at gmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115424

            Bug ID: 115424
           Summary: 'auto' type inference not working when struct declared
                    in rhs, even when the final type is not anonymous
           Product: gcc
           Version: 15.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c
          Assignee: unassigned at gcc dot gnu.org
          Reporter: malekwryyy at gmail dot com
  Target Milestone: ---

for example this code:

```
int main()
{
    auto x = (struct { int i; }){1}.i;
}
```

Compiling the above with gcc 15.0 give the following error:

```
<source>: In function 'main':
<source>:6:15: error: 'struct <anonymous>' defined in underspecified object
initializer
    6 |     auto x = (struct { int i; }){1}.i;
      |               ^~~~~~
Compiler returned: 1
```

When I replace it with 'typeof' it compiles fine:


```
int main()
{
    typeof((struct { int i; }){1}.i) x = (struct { int i; }){1}.i;
}
```

[Bug c/115424] 'auto' type inference not working when struct declared in rhs, even when the final type is not anonymous

[pinskia at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115424

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Hmm from the commit message (r13-3620-ge3c898e12d0ace):
```
    * The standard feature disallows the declaration from declaring
      anything that's not an ordinary identifier (thus, the initializer
      cannot declare a tag or the members of a structure or union), while
      making it undefined behavior for it to declare more than one
      ordinary identifier.  (For the latter, while I keep the existing
      error from __auto_type in the case of more than one declarator, I
      don't restrict other ordinary identifiers from being declared in
      inner scopes such as GNU statement expressions.  I do however
      disallow defining the members of an enumeration inside the
      initializer (if the enum definition has no tag, that doesn't
      actually violate a constraint), to avoid an enum type becoming
      accessible beyond where it would have been without auto.
      (Preventing new types from escaping the initializer - thus, ensuring
      that anything written with auto corresponds to something that could
      have been written without auto, modulo multiple evaluation of VLA
      size expressions when not using auto - is a key motivation for some
      restrictions on what can be declared in the initializer.)

    The rule on shadowing and restrictions on other declarations in the
    initializer are actually general rules for what C2x calls
    underspecified declarations, a description that covers constexpr as
    well as auto (in particular, this disallows a constexpr initializer
    from referencing the variable being initialized).  Thus, some of the
    code added for those restrictions will also be of use in implementing
    C2x constexpr.

```

So this might be expected.

[Bug c/115424] 'auto' type inference not working when struct declared in rhs, even when the final type is not anonymous

[jsm28 at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115424

--- Comment #2 from Joseph S. Myers <jsm28 at gcc dot gnu.org> ---
These cases were later changed to implementation-defined, so we aren't actually
required to diagnose them in the final version of the feature in C23.