* [committed] libstdc++: Fix constraints on std::optional comparisons [PR 96269]
@ 2020-11-05 19:09 Jonathan Wakely
2020-11-05 19:50 ` Jonathan Wakely
0 siblings, 1 reply; 4+ messages in thread
From: Jonathan Wakely @ 2020-11-05 19:09 UTC (permalink / raw)
To: libstdc++, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 624 bytes --]
The relational operators for std::optional were using the wrong types
in the declval expressions used to constrain them. Instead of using
const lvalues they were using non-const rvalues, which meant that a type
might satisfy the constraints but then give an error when the function
body was instantiated.
libstdc++-v3/ChangeLog:
PR libstdc++/96269
* include/std/optional (operator==, operator!=, operator<)
(operator>, operator<=, operator>=): Fix types used in
SFINAE constraints.
* testsuite/20_util/optional/relops/96269.cc: New test.
Tested powerpc64le-linux. Committed to trunk.
I'll backport to gcc-10 too.
[-- Attachment #2: patch.txt --]
[-- Type: text/plain, Size: 10691 bytes --]
commit cdd2d448d8200ed5ebcb232163954367b553291e
Author: Jonathan Wakely <jwakely@redhat.com>
Date: Thu Nov 5 18:36:19 2020
libstdc++: Fix constraints on std::optional comparisons [PR 96269]
The relational operators for std::optional were using the wrong types
in the declval expressions used to constrain them. Instead of using
const lvalues they were using non-const rvalues, which meant that a type
might satisfy the constraints but then give an error when the function
body was instantiated.
libstdc++-v3/ChangeLog:
PR libstdc++/96269
* include/std/optional (operator==, operator!=, operator<)
(operator>, operator<=, operator>=): Fix types used in
SFINAE constraints.
* testsuite/20_util/optional/relops/96269.cc: New test.
diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional
index f9f42efe09ce..5ea5b39d0e69 100644
--- a/libstdc++-v3/include/std/optional
+++ b/libstdc++-v3/include/std/optional
@@ -1002,11 +1002,41 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __optional_relop_t =
enable_if_t<is_convertible<_Tp, bool>::value, bool>;
+ template<typename _Tp, typename _Up>
+ using __optional_eq_t = __optional_relop_t<
+ decltype(std::declval<const _Tp&>() == std::declval<const _Up&>())
+ >;
+
+ template<typename _Tp, typename _Up>
+ using __optional_ne_t = __optional_relop_t<
+ decltype(std::declval<const _Tp&>() != std::declval<const _Up&>())
+ >;
+
+ template<typename _Tp, typename _Up>
+ using __optional_lt_t = __optional_relop_t<
+ decltype(std::declval<const _Tp&>() < std::declval<const _Up&>())
+ >;
+
+ template<typename _Tp, typename _Up>
+ using __optional_gt_t = __optional_relop_t<
+ decltype(std::declval<const _Tp&>() > std::declval<const _Up&>())
+ >;
+
+ template<typename _Tp, typename _Up>
+ using __optional_le_t = __optional_relop_t<
+ decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>())
+ >;
+
+ template<typename _Tp, typename _Up>
+ using __optional_ge_t = __optional_relop_t<
+ decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>())
+ >;
+
// Comparisons between optional values.
template<typename _Tp, typename _Up>
constexpr auto
operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
+ -> __optional_eq_t<_Tp, _Up>
{
return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
&& (!__lhs || *__lhs == *__rhs);
@@ -1015,7 +1045,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Up>
constexpr auto
operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
+ -> __optional_ne_t<_Tp, _Up>
{
return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
|| (static_cast<bool>(__lhs) && *__lhs != *__rhs);
@@ -1024,7 +1054,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Up>
constexpr auto
operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
+ -> __optional_lt_t<_Tp, _Up>
{
return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
}
@@ -1032,7 +1062,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Up>
constexpr auto
operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
+ -> __optional_gt_t<_Tp, _Up>
{
return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
}
@@ -1040,7 +1070,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Up>
constexpr auto
operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
+ -> __optional_le_t<_Tp, _Up>
{
return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
}
@@ -1048,7 +1078,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Up>
constexpr auto
operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
+ -> __optional_ge_t<_Tp, _Up>
{
return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
}
@@ -1134,73 +1164,73 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Up>
constexpr auto
operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
+ -> __optional_eq_t<_Tp, _Up>
{ return __lhs && *__lhs == __rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
- -> __optional_relop_t<decltype(declval<_Up>() == declval<_Tp>())>
+ -> __optional_eq_t<_Up, _Tp>
{ return __rhs && __lhs == *__rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
+ -> __optional_ne_t<_Tp, _Up>
{ return !__lhs || *__lhs != __rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
- -> __optional_relop_t<decltype(declval<_Up>() != declval<_Tp>())>
+ -> __optional_ne_t<_Up, _Tp>
{ return !__rhs || __lhs != *__rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
+ -> __optional_lt_t<_Tp, _Up>
{ return !__lhs || *__lhs < __rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
- -> __optional_relop_t<decltype(declval<_Up>() < declval<_Tp>())>
+ -> __optional_lt_t<_Up, _Tp>
{ return __rhs && __lhs < *__rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
+ -> __optional_gt_t<_Tp, _Up>
{ return __lhs && *__lhs > __rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
- -> __optional_relop_t<decltype(declval<_Up>() > declval<_Tp>())>
+ -> __optional_gt_t<_Up, _Tp>
{ return !__rhs || __lhs > *__rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
+ -> __optional_le_t<_Tp, _Up>
{ return !__lhs || *__lhs <= __rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
- -> __optional_relop_t<decltype(declval<_Up>() <= declval<_Tp>())>
+ -> __optional_le_t<_Up, _Tp>
{ return __rhs && __lhs <= *__rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
- -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
+ -> __optional_ge_t<_Tp, _Up>
{ return __lhs && *__lhs >= __rhs; }
template<typename _Tp, typename _Up>
constexpr auto
operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
- -> __optional_relop_t<decltype(declval<_Up>() >= declval<_Tp>())>
+ -> __optional_ge_t<_Up, _Tp>
{ return !__rhs || __lhs >= *__rhs; }
#ifdef __cpp_lib_three_way_comparison
diff --git a/libstdc++-v3/testsuite/20_util/optional/relops/96269.cc b/libstdc++-v3/testsuite/20_util/optional/relops/96269.cc
new file mode 100644
index 000000000000..2054d3643c66
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/optional/relops/96269.cc
@@ -0,0 +1,76 @@
+// Copyright (C) 2020 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++2a" }
+// { dg-do compile { target c++2a } }
+
+#include <optional>
+
+struct X
+{
+ template <typename T>
+ bool operator==(const T&) /* not const */ { return false; }
+
+ template <typename T>
+ bool operator!=(const T&) /* not const */ { return false; }
+
+ template <typename T>
+ bool operator<(const T&) /* not const */ { return false; }
+
+ template <typename T>
+ bool operator>(const T&) /* not const */ { return false; }
+
+ template <typename T>
+ bool operator<=(const T&) /* not const */ { return false; }
+
+ template <typename T>
+ bool operator>=(const T&) /* not const */ { return false; }
+};
+
+void test01()
+{
+ // PR 96269 optional comparison with nullopt fails
+ std::optional<X> x;
+ bool eq [[maybe_unused]] = std::nullopt == x;
+
+ bool ne [[maybe_unused]] = std::nullopt != x;
+ bool lt [[maybe_unused]] = std::nullopt < x;
+ bool gt [[maybe_unused]] = std::nullopt > x;
+ bool le [[maybe_unused]] = std::nullopt <= x;
+ bool ge [[maybe_unused]] = std::nullopt >= x;
+}
+
+template<typename T>
+ concept optional_lt_cmp
+ = requires(std::optional<T> o, T t) { { o < t } -> std::same_as<bool>; };
+
+template<typename T>
+ concept optional_gt_cmp
+ = requires(std::optional<T> o, T t) { { o > t } -> std::same_as<bool>; };
+
+template<typename T>
+ concept optional_le_cmp
+ = requires(std::optional<T> o, T t) { { o <= t } -> std::same_as<bool>; };
+
+template<typename T>
+ concept optional_ge_cmp
+ = requires(std::optional<T> o, T t) { { o >= t } -> std::same_as<bool>; };
+
+static_assert( ! optional_lt_cmp<X> );
+static_assert( ! optional_gt_cmp<X> );
+static_assert( ! optional_le_cmp<X> );
+static_assert( ! optional_ge_cmp<X> );
^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [committed] libstdc++: Fix constraints on std::optional comparisons [PR 96269]
2020-11-05 19:09 [committed] libstdc++: Fix constraints on std::optional comparisons [PR 96269] Jonathan Wakely
@ 2020-11-05 19:50 ` Jonathan Wakely
2020-11-05 20:12 ` Ville Voutilainen
0 siblings, 1 reply; 4+ messages in thread
From: Jonathan Wakely @ 2020-11-05 19:50 UTC (permalink / raw)
To: libstdc++, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 896 bytes --]
On 05/11/20 19:09 +0000, Jonathan Wakely wrote:
>The relational operators for std::optional were using the wrong types
>in the declval expressions used to constrain them. Instead of using
>const lvalues they were using non-const rvalues, which meant that a type
>might satisfy the constraints but then give an error when the function
>body was instantiated.
>
>libstdc++-v3/ChangeLog:
>
> PR libstdc++/96269
> * include/std/optional (operator==, operator!=, operator<)
> (operator>, operator<=, operator>=): Fix types used in
> SFINAE constraints.
> * testsuite/20_util/optional/relops/96269.cc: New test.
>
>Tested powerpc64le-linux. Committed to trunk.
When concepts are supported we can make the alias templates
__optional_eq_t et al use a requires-expression instead of SFINAE.
This is potentially faster to compile, given expected improvements
to C++20 compilers.
I'm testing this patch.
[-- Attachment #2: patch.txt --]
[-- Type: text/x-patch, Size: 2717 bytes --]
commit c5d8e2ba0ad20425cc7778152824d9e5267b0ec5
Author: Jonathan Wakely <jwakely@redhat.com>
Date: Thu Nov 5 19:45:52 2020
libstdc++: Use concepts to constrain std::optional relops
When concepts are supported we can make the alias templates
__optional_eq_t et al use a requires-expression instead of SFINAE.
This is potentially faster to compile, given expected improvements
to C++20 compilers.
libstdc++-v3/ChangeLog:
* include/std/optional [__cpp_concepts] (__optional_eq_t)
(__optional_ne_t, __optional_lt_t, __optional_gt_t)
(__optional_le_t, __optional_ge_t): Use requires-clause on
alias template.
diff --git a/libstdc++-v3/include/std/optional b/libstdc++-v3/include/std/optional
index 5ea5b39d0e69..4e9618648250 100644
--- a/libstdc++-v3/include/std/optional
+++ b/libstdc++-v3/include/std/optional
@@ -998,9 +998,48 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
void reset() noexcept { this->_M_reset(); }
};
+#if __cpp_lib_concepts
+ template<typename _Tp, typename _Up>
+ requires requires (const _Tp __t, const _Up __u) {
+ { __t == __u } -> convertible_to<bool>;
+ }
+ using __optional_eq_t = bool;
+
+ template<typename _Tp, typename _Up>
+ requires requires (const _Tp __t, const _Up __u) {
+ { __t != __u } -> convertible_to<bool>;
+ }
+ using __optional_ne_t = bool;
+
+ template<typename _Tp, typename _Up>
+ requires requires (const _Tp __t, const _Up __u) {
+ { __t < __u } -> convertible_to<bool>;
+ }
+ using __optional_lt_t = bool;
+
+ template<typename _Tp, typename _Up>
+ requires requires (const _Tp __t, const _Up __u) {
+ { __t > __u } -> convertible_to<bool>;
+ }
+ using __optional_gt_t = bool;
+
+ template<typename _Tp, typename _Up>
+ requires requires (const _Tp __t, const _Up __u) {
+ { __t <= __u } -> convertible_to<bool>;
+ }
+ using __optional_le_t = bool;
+
+ template<typename _Tp, typename _Up>
+ requires requires (const _Tp __t, const _Up __u) {
+ { __t >= __u } -> convertible_to<bool>;
+ }
+ using __optional_ge_t = bool;
+
+#else // concepts
+
template<typename _Tp>
using __optional_relop_t =
- enable_if_t<is_convertible<_Tp, bool>::value, bool>;
+ enable_if_t<is_convertible_v<_Tp, bool>, bool>;
template<typename _Tp, typename _Up>
using __optional_eq_t = __optional_relop_t<
@@ -1031,6 +1070,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
using __optional_ge_t = __optional_relop_t<
decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>())
>;
+#endif // concepts
// Comparisons between optional values.
template<typename _Tp, typename _Up>
^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [committed] libstdc++: Fix constraints on std::optional comparisons [PR 96269]
2020-11-05 19:50 ` Jonathan Wakely
@ 2020-11-05 20:12 ` Ville Voutilainen
2020-11-05 20:59 ` Jonathan Wakely
0 siblings, 1 reply; 4+ messages in thread
From: Ville Voutilainen @ 2020-11-05 20:12 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: libstdc++, gcc-patches List
On Thu, 5 Nov 2020 at 21:52, Jonathan Wakely via Libstdc++
<libstdc++@gcc.gnu.org> wrote:
>
> On 05/11/20 19:09 +0000, Jonathan Wakely wrote:
> >The relational operators for std::optional were using the wrong types
> >in the declval expressions used to constrain them. Instead of using
> >const lvalues they were using non-const rvalues, which meant that a type
> >might satisfy the constraints but then give an error when the function
> >body was instantiated.
> >
> >libstdc++-v3/ChangeLog:
> >
> > PR libstdc++/96269
> > * include/std/optional (operator==, operator!=, operator<)
> > (operator>, operator<=, operator>=): Fix types used in
> > SFINAE constraints.
> > * testsuite/20_util/optional/relops/96269.cc: New test.
> >
> >Tested powerpc64le-linux. Committed to trunk.
>
> When concepts are supported we can make the alias templates
> __optional_eq_t et al use a requires-expression instead of SFINAE.
> This is potentially faster to compile, given expected improvements
> to C++20 compilers.
>
> I'm testing this patch.
It concerns me that we'd have such conditional conceptifying just
because it's possibly faster to compile.
There's more types where we'd want to conditionally use concepts, but
perhaps we want to think a bit
more how to do that in our source code, rather than just make them
preprocessor-conditionals in the same
header. We might entertain conceptifying tuple, when concepts are
available. That may end up being
fairly verbose if it's done with preprocessor in <tuple>.
That's not to say that I'm objecting to this as such; I merely think
we want to be a bit careful with
conceptifying, and be rather instantly prepared to entertain doing it
with a slightly different source code
structure, which may involve splitting things across more files, which
would then involve adding more
headers that are installed.
^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [committed] libstdc++: Fix constraints on std::optional comparisons [PR 96269]
2020-11-05 20:12 ` Ville Voutilainen
@ 2020-11-05 20:59 ` Jonathan Wakely
0 siblings, 0 replies; 4+ messages in thread
From: Jonathan Wakely @ 2020-11-05 20:59 UTC (permalink / raw)
To: Ville Voutilainen; +Cc: libstdc++, gcc-patches List
On 05/11/20 22:12 +0200, Ville Voutilainen via Libstdc++ wrote:
>On Thu, 5 Nov 2020 at 21:52, Jonathan Wakely via Libstdc++
><libstdc++@gcc.gnu.org> wrote:
>>
>> On 05/11/20 19:09 +0000, Jonathan Wakely wrote:
>> >The relational operators for std::optional were using the wrong types
>> >in the declval expressions used to constrain them. Instead of using
>> >const lvalues they were using non-const rvalues, which meant that a type
>> >might satisfy the constraints but then give an error when the function
>> >body was instantiated.
>> >
>> >libstdc++-v3/ChangeLog:
>> >
>> > PR libstdc++/96269
>> > * include/std/optional (operator==, operator!=, operator<)
>> > (operator>, operator<=, operator>=): Fix types used in
>> > SFINAE constraints.
>> > * testsuite/20_util/optional/relops/96269.cc: New test.
>> >
>> >Tested powerpc64le-linux. Committed to trunk.
>>
>> When concepts are supported we can make the alias templates
>> __optional_eq_t et al use a requires-expression instead of SFINAE.
>> This is potentially faster to compile, given expected improvements
>> to C++20 compilers.
>>
>> I'm testing this patch.
>
>It concerns me that we'd have such conditional conceptifying just
>because it's possibly faster to compile.
>There's more types where we'd want to conditionally use concepts, but
>perhaps we want to think a bit
>more how to do that in our source code, rather than just make them
>preprocessor-conditionals in the same
>header. We might entertain conceptifying tuple, when concepts are
>available. That may end up being
>fairly verbose if it's done with preprocessor in <tuple>.
>
>That's not to say that I'm objecting to this as such; I merely think
>we want to be a bit careful with
>conceptifying, and be rather instantly prepared to entertain doing it
>with a slightly different source code
>structure, which may involve splitting things across more files, which
>would then involve adding more
>headers that are installed.
I agree. I only considered doing it here (and am posting it for
comment rather than committing it right away) because we already have
the alias helpers which are used in multiple places in the file.
Without those, every relational operator would look like this if we
used concepts conditionally:
template<typename _Tp, typename _Up>
constexpr auto
operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
#if __cpp_lib_concepts
requires requires(const _Tp __t, const _Up __u) {
{ *__lhs == *__rhs } -> convertible_to<bool>;
}
#else
-> enable_if_t<is_convertible_v<
decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
bool>
#endif
{
return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
&& (!__lhs || *__lhs == *__rhs);
}
Or:
template<typename _Tp, typename _Up>
constexpr auto
operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
#if __cpp_lib_concepts
requires requires { *__lhs == *__rhs } -> convertible_to<bool>; }
#else
-> enable_if_t<is_convertible_v<decltype(*__lhs == *__rhs), bool>, bool>
#endif
{
return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
&& (!__lhs || *__lhs == *__rhs);
}
Yuck.
The second one is less verbose, but does overload resolution and type
deduction for optional<_Tp>::operator* and optional<_Up>::operator*.
That's unnecessary (and so compiles slower) because we know the result
types are just const _Tp& and const _Up&, so the first version uses
those types directly.
Either way, having that #if-#else-#endif on every relational operator
is NOT appealing. But since all the operators already use aliases like
__optional_eq_t any changes are localized to those helpers. The actual
rel ops themselves don't change.
We definitely want to think about the trade offs though. So far we
only use concepts in code that only has to compile as C++20, so we
don't need to provide a non-concepts fallback for C++17, or where it's
required for conformance (e.g. iterator_traits). That's definitely
more palatable than preprocessor conditions choosing between two
functionally equivalent ways to do the same thing.
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2020-11-05 20:59 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-11-05 19:09 [committed] libstdc++: Fix constraints on std::optional comparisons [PR 96269] Jonathan Wakely
2020-11-05 19:50 ` Jonathan Wakely
2020-11-05 20:12 ` Ville Voutilainen
2020-11-05 20:59 ` Jonathan Wakely
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).