[Bug c++/102000] Defaulted consteval default constructor that performs no initialization is not rejected

["hstong at ca dot ibm.com" <gcc-bugzilla@gcc.gnu.org>]

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

Hubert Tong <hstong at ca dot ibm.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |hstong at ca dot ibm.com

--- Comment #4 from Hubert Tong <hstong at ca dot ibm.com> ---
(In reply to Johel Ernesto Guerrero Peña from comment #3)
> https://bugs.llvm.org/show_bug.cgi?id=51560#c1 points out
> > I'm not sure what you think the problem is here.  The constructor isn't getting called; see http://eel.is/c++draft/dcl.init.general#8 .
> It seems to me that they are right and the example above is well-formed.

That depends on what "the semantic constraints for default-initialization are
checked" means.

(In reply to Johel Ernesto Guerrero Peña from comment #0)
> ```
>     An immediate invocation shall be a constant expression. --
> https://eel.is/c++draft/expr.const#13.sentence-3
> 
> Lots of wording in between...
> 
>     2 A variable or temporary object o is constant-initialized if
>     (2.1) either it has an initializer or its default-initialization results
> in some initialization being performed, and
>     -- https://eel.is/c++draft/expr.const#2
>     7 To default-initialize an object of type T means:
>     (7.3) Otherwise, no initialization is performed.
>     -- https://eel.is/c++draft/dcl.init.general#7
> ```

That wording would be relevant for a similar case involving `constinit`. Here,
the relevant wording is in 7.7 [expr.const] paragraph 12 (and the uninitialized
`int` is fine with the current wording). The example needs to be changed to use
pointers:
```
struct A {
  consteval A() = default;
private:
  int *m;
};

struct B {
  consteval B() = default;
private:
  int *m, *n = 0;
};

void f() {
  A a; // GCC accepts this despite pointer with indeterminate value
  B b; // GCC rejects this
}
```

So it seems GCC just doesn't do certain checking when the constructor is
trivial.