[Bug c++/111440] New: wrong-code for ternary with reference-compatible arguments

[Bug c++/111440] New: wrong-code for ternary with reference-compatible arguments

[leni536 at gmail dot com]

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

            Bug ID: 111440
           Summary: wrong-code for ternary with reference-compatible
                    arguments
           Product: gcc
           Version: 13.2.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: leni536 at gmail dot com
  Target Milestone: ---

version: g++ 13.2.0
flags: -std=c++20 -O2 -pedantic-errors

Consider the following code:

```
template <typename T>
void foo();,

bool bar() {
    int * ptr = nullptr;
    const int * const cptr = nullptr;
    decltype(auto) res = true ? ptr : cptr;
    foo<decltype(res)>(); // calls void<int const*>();
    return &res == &ptr; // returns false
}
```

https://godbolt.org/z/cW5bxch5K

The observed behavior is described in the code comments.

The expected behavior is that the ternary expression is an lvalue of type
`const int * const` and the result refers to `ptr`.

https://timsong-cpp.github.io/cppwp/n4868/expr.cond#4.1 applies. The target
type is `const int * const&`, E1 is an lvalue of type `int *`.

`int *` is reference-compatible with `const int * const`, as `int**` is
convertible to `const int * const *`.

https://timsong-cpp.github.io/cppwp/n4868/dcl.init.ref#5.1.1 applies, a
reference of type `const int * const&` can be initialized by an lvalue of type
`int*`, and the reference binds directly.

The wording for "reference-compatible" was changed in the resolution of
https://cplusplus.github.io/CWG/issues/2352.html, so earlier standard modes are
probably similarly affected.

[Bug c++/111440] wrong-code for ternary with reference-compatible arguments

[pinskia at gcc dot gnu.org]

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

--- Comment #1 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
Note clang changed between version 9 and 10 for the defect report it seems ...

[Bug c++/111440] wrong-code for ternary with reference-compatible arguments

[pinskia at gcc dot gnu.org]

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

--- Comment #2 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
clang change:
https://github.com/llvm/llvm-project/commit/f041e9ad706aee7987c5299427c33424fcabbd0d

[Bug c++/111440] wrong-code for ternary with reference-compatible arguments due to C++ defect report 2352

[leni536 at gmail dot com]

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

--- Comment #3 from Lénárd Szolnoki <leni536 at gmail dot com> ---
Note that GCC seems to implement CWG2352 outside of ternary operators.

https://godbolt.org/z/rnMcPqE7b

```
template <typename T>
void foo();

bool bar() {
    int * ptr = nullptr;
    const int * const &ref = ptr;
    return &ref == &ptr; // returns true
}
```

from GCC 10 `bar` returns true.

[Bug c++/111440] wrong-code for ternary with reference-compatible arguments due to C++ defect report 2352

[pinskia at gcc dot gnu.org]

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

--- Comment #4 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
(In reply to Lénárd Szolnoki from comment #3)
> Note that GCC seems to implement CWG2352 outside of ternary operators.

Yes that was done in GCC 10 (see PR 91844).