[Bug c++/114504] New: Non-structural type accepted as non-type template parameter type

[Bug c++/114504] New: Non-structural type accepted as non-type template parameter type

[ted at lyncon dot se]

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

            Bug ID: 114504
           Summary: Non-structural type accepted as non-type template
                    parameter type
           Product: gcc
           Version: 14.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: ted at lyncon dot se
  Target Milestone: ---

gcc accepts `NonStructuralType` as a non-type template parameter type below:
```
struct StructuralType1 {
    constexpr StructuralType1(int A) : a(A) {}
    int a;
};

struct NonStructuralType {
    constexpr NonStructuralType(int A) : a(A) {}
private:
    int a;
};

template <typename T>
concept is_structural = requires { []<T t> {}; };

static_assert(is_structural<StructuralType1>,
              "BUG! StructuralType1 is not structural");

static_assert(!is_structural<NonStructuralType>,
              "BUG! NontStructuralType is structural");

int main() {}
```
I was expecting `[]<T t>{}` to fail in the concept. The program compiles with
clang++, icx and MSVC.

[Bug c++/114504] Non-structural type accepted as non-type template parameter type

[pinskia at gcc dot gnu.org]

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

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
     Ever confirmed|0                           |1
   Last reconfirmed|                            |2024-03-27

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
So it looks like it is just an issue with the way requires is handled.
That is doing it outside of a requires rejects the code correctly:
```
...


template <typename T>
int f(void)
{
        []<T t> {}; 
        return 0;
}

auto t = f<NonStructuralType>();

```

Is rejected correctly with:
```

<source>: In instantiation of 'int f() [with T = NonStructuralType]':
<source>:24:30:   required from here
   24 | auto t = f<NonStructuralType>();
      |          ~~~~~~~~~~~~~~~~~~~~^~
<source>:20:9: error: 'NonStructuralType' is not a valid type for a template
non-type parameter because it is not structural
   20 |         []<T t> {};
      |         ^~~~~~~~~~
<source>:10:9: note: 'NonStructuralType::a' is not public
   10 |     int a;
      |         ^
```

[Bug c++/114504] Non-structural type accepted as non-type template parameter type for a template lambda function while in a concept

[pinskia at gcc dot gnu.org]

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

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |c++-lambda
            Summary|Non-structural type         |Non-structural type
                   |accepted as non-type        |accepted as non-type
                   |template parameter type     |template parameter type for
                   |while in concept            |a template lambda function
                   |                            |while in a concept

--- Comment #2 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Note GCC does the correct thing for:
```
...
template <typename T, T a> int f(void) { return 0; }

template <typename T>
concept is_structural = requires { f<T, T{1}>(); };

static_assert(!is_structural<NonStructuralType>);
```

So it is looking lambda related.

This also fails:
```
...
template <typename T>
void f(void)
{
        []<T t> {}; 
}

template <typename T>
concept is_structural = requires { f<T>(); };

static_assert(!is_structural<NonStructuralType>);
```

More proof that is lambda related.