* [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable}
@ 2020-10-23 23:32 Ville Voutilainen
2020-10-23 23:34 ` Ville Voutilainen
` (2 more replies)
0 siblings, 3 replies; 9+ messages in thread
From: Ville Voutilainen @ 2020-10-23 23:32 UTC (permalink / raw)
To: gcc-patches List, libstdc++, Jason Merrill
[-- Attachment #1: Type: text/plain, Size: 1182 bytes --]
Finishing testing on Linux-PPC64. Ok for trunk if tests pass?
2020-10-24 Ville Voutilainen <ville.voutilainen@gmail.com>
gcc/c-family/ChangeLog:
Implement __is_nothrow_{constructible,assignable}
* c-common.c (__is_nothrow_assignable): New.
(__is_nothrow_constructible): Likewise.
* c-common.h (RID_IS_NOTHROW_ASSIGNABLE): New.
(RID_IS_NOTHROW_CONSTRUCTIBLE): Likewise.
gcc/cp/ChangeLog:
Implement __is_nothrow_{constructible,assignable}
* cp-tree.h (CPTK_IS_NOTHROW_ASSIGNABLE): New.
(CPTK_IS_NOTHROW_CONSTRUCTIBLE): Likewise.
(is_nothrow_xible): Likewise.
* method.c (__is_nothrow_xible): New.
* parser.c (cp_parser_primary_expression): Handle the new RID_*.
(cp_parser_trait_expr): Likewise.
* semantics.c (trait_expr_value): Handle the new RID_*.
(finish_trait_expr): Likewise.
libstdc++-v3/ChangeLog:
Implement __is_nothrow_{constructible,assignable}
* include/std/type_traits (__is_nt_constructible_impl): Remove.
(__is_nothrow_constructible_impl): Adjust.
(is_nothrow_default_constructible): Likewise.
(__is_nt_assignable_impl): Remove.
(__is_nothrow_assignable_impl): Adjust.
[-- Attachment #2: is-nt-constructible.diff --]
[-- Type: text/x-patch, Size: 11865 bytes --]
diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index e16ca3894bc..098a36e4d67 100644
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -527,6 +527,8 @@ const struct c_common_resword c_common_reswords[] =
{ "while", RID_WHILE, 0 },
{ "__is_assignable", RID_IS_ASSIGNABLE, D_CXXONLY },
{ "__is_constructible", RID_IS_CONSTRUCTIBLE, D_CXXONLY },
+ { "__is_nothrow_assignable", RID_IS_NOTHROW_ASSIGNABLE, D_CXXONLY },
+ { "__is_nothrow_constructible", RID_IS_NOTHROW_CONSTRUCTIBLE, D_CXXONLY },
/* C++ transactional memory. */
{ "synchronized", RID_SYNCHRONIZED, D_CXX_OBJC | D_TRANSMEM },
diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index 3d96092a297..24a4a8e7fe3 100644
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -176,6 +176,7 @@ enum rid
RID_IS_TRIVIALLY_COPYABLE,
RID_IS_UNION, RID_UNDERLYING_TYPE,
RID_IS_ASSIGNABLE, RID_IS_CONSTRUCTIBLE,
+ RID_IS_NOTHROW_ASSIGNABLE, RID_IS_NOTHROW_CONSTRUCTIBLE,
/* C++11 */
RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT,
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 5c06ac3789e..1ce20989e13 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -1323,7 +1323,9 @@ enum cp_trait_kind
CPTK_IS_UNION,
CPTK_UNDERLYING_TYPE,
CPTK_IS_ASSIGNABLE,
- CPTK_IS_CONSTRUCTIBLE
+ CPTK_IS_CONSTRUCTIBLE,
+ CPTK_IS_NOTHROW_ASSIGNABLE,
+ CPTK_IS_NOTHROW_CONSTRUCTIBLE
};
/* The types that we are processing. */
@@ -6752,6 +6754,7 @@ extern void use_thunk (tree, bool);
extern bool trivial_fn_p (tree);
extern tree forward_parm (tree);
extern bool is_trivially_xible (enum tree_code, tree, tree);
+extern bool is_nothrow_xible (enum tree_code, tree, tree);
extern bool is_xible (enum tree_code, tree, tree);
extern tree get_defaulted_eh_spec (tree, tsubst_flags_t = tf_warning_or_error);
extern bool maybe_explain_implicit_delete (tree);
diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index 6e4c5f7e83b..2ffc86cbd81 100644
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -1933,6 +1933,21 @@ is_trivially_xible (enum tree_code code, tree to, tree from)
return !nt;
}
+/* Returns true iff TO is nothrow assignable (if CODE is MODIFY_EXPR) or
+ constructible (otherwise) from FROM, which is a single type for
+ assignment or a list of types for construction. */
+
+bool
+is_nothrow_xible (enum tree_code code, tree to, tree from)
+{
+ tree expr;
+ expr = is_xible_helper (code, to, from, /*trivial*/false);
+
+ if (expr == NULL_TREE || expr == error_mark_node)
+ return false;
+ return expr_noexcept_p (expr, tf_none);
+}
+
/* Returns true iff TO is assignable (if CODE is MODIFY_EXPR) or
constructible (otherwise) from FROM, which is a single type for
assignment or a list of types for construction. */
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 7ec7d42773c..cce3d0a679e 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -5637,6 +5637,8 @@ cp_parser_primary_expression (cp_parser *parser,
case RID_IS_UNION:
case RID_IS_ASSIGNABLE:
case RID_IS_CONSTRUCTIBLE:
+ case RID_IS_NOTHROW_ASSIGNABLE:
+ case RID_IS_NOTHROW_CONSTRUCTIBLE:
return cp_parser_trait_expr (parser, token->keyword);
// C++ concepts
@@ -10501,6 +10503,14 @@ cp_parser_trait_expr (cp_parser* parser, enum rid keyword)
kind = CPTK_IS_CONSTRUCTIBLE;
variadic = true;
break;
+ case RID_IS_NOTHROW_ASSIGNABLE:
+ kind = CPTK_IS_NOTHROW_ASSIGNABLE;
+ binary = true;
+ break;
+ case RID_IS_NOTHROW_CONSTRUCTIBLE:
+ kind = CPTK_IS_NOTHROW_CONSTRUCTIBLE;
+ variadic = true;
+ break;
default:
gcc_unreachable ();
}
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 1e42cd799c2..ac488478f36 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -10133,6 +10133,12 @@ trait_expr_value (cp_trait_kind kind, tree type1, tree type2)
case CPTK_IS_CONSTRUCTIBLE:
return is_xible (INIT_EXPR, type1, type2);
+ case CPTK_IS_NOTHROW_ASSIGNABLE:
+ return is_nothrow_xible (MODIFY_EXPR, type1, type2);
+
+ case CPTK_IS_NOTHROW_CONSTRUCTIBLE:
+ return is_nothrow_xible (INIT_EXPR, type1, type2);
+
default:
gcc_unreachable ();
return false;
@@ -10213,6 +10219,8 @@ finish_trait_expr (location_t loc, cp_trait_kind kind, tree type1, tree type2)
case CPTK_IS_TRIVIALLY_ASSIGNABLE:
case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE:
+ case CPTK_IS_NOTHROW_ASSIGNABLE:
+ case CPTK_IS_NOTHROW_CONSTRUCTIBLE:
if (!check_trait_type (type1)
|| !check_trait_type (type2))
return error_mark_node;
diff --git a/gcc/testsuite/g++.dg/ext/is_nothrow_constructible1.C b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible1.C
new file mode 100644
index 00000000000..472acf9f88f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible1.C
@@ -0,0 +1,48 @@
+// { dg-do compile { target c++11 } }
+
+struct A { };
+struct B { B(); operator int(); };
+struct C {
+ C() = default;
+ C(const C&);
+ C(C&&) = default;
+ C& operator=(C&&);
+ C& operator= (const C&) = default;
+};
+struct D { ~D() noexcept(false) {} };
+
+#define SA(X) static_assert((X),#X)
+
+SA(__is_nothrow_constructible(A));
+SA(__is_nothrow_constructible(A,A));
+SA(!__is_nothrow_constructible(B));
+SA(__is_nothrow_constructible(B,B));
+
+SA(!__is_nothrow_constructible(A,B));
+SA(!__is_nothrow_constructible(B,A));
+
+SA(__is_nothrow_constructible(C));
+SA(__is_nothrow_constructible(C,C));
+SA(!__is_nothrow_constructible(C,C&));
+SA(__is_nothrow_assignable(C,C&));
+SA(!__is_nothrow_assignable(C,C));
+SA(!__is_nothrow_assignable(C,C&&));
+SA(!__is_nothrow_assignable(void,int));
+SA(!__is_nothrow_assignable(const void,int));
+SA(!__is_nothrow_assignable(volatile void,int));
+SA(!__is_nothrow_assignable(const volatile void,int));
+
+SA(__is_nothrow_constructible(int,int));
+SA(__is_nothrow_constructible(int,double));
+SA(!__is_nothrow_constructible(int,B));
+SA(!__is_nothrow_constructible(void,int));
+SA(!__is_nothrow_constructible(const void,int));
+SA(!__is_nothrow_constructible(volatile void,int));
+SA(!__is_nothrow_constructible(const volatile void,int));
+SA(!__is_nothrow_constructible(int, void*));
+SA(!__is_nothrow_constructible(int, int*));
+SA(!__is_nothrow_constructible(int, const int*));
+SA(!__is_nothrow_constructible(int*, void*));
+SA(!__is_nothrow_constructible(int*, const int*));
+
+SA(!__is_nothrow_constructible(D));
diff --git a/gcc/testsuite/g++.dg/ext/is_nothrow_constructible2.C b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible2.C
new file mode 100644
index 00000000000..86b9668da6e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible2.C
@@ -0,0 +1,15 @@
+// { dg-do compile { target c++11 } }
+
+struct X {
+ X() = default;
+ template<class... U> X(U...) noexcept;
+};
+
+struct Y {
+ template<class... U> Y(U...);
+};
+
+#define SA(X) static_assert((X),#X)
+
+SA(__is_nothrow_constructible(X));
+SA(!__is_nothrow_constructible(Y));
diff --git a/gcc/testsuite/g++.dg/ext/is_nothrow_constructible3.C b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible3.C
new file mode 100644
index 00000000000..220ee0bb89e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible3.C
@@ -0,0 +1,8 @@
+// { dg-do compile { target c++11 } }
+
+template <class T, class... Args> void bar() {
+ static_assert(__is_nothrow_constructible(T, Args...), "");
+}
+
+template void bar<int>();
+template void bar<int,int>();
diff --git a/gcc/testsuite/g++.dg/ext/is_nothrow_constructible4.C b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible4.C
new file mode 100644
index 00000000000..9448c2d31e4
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible4.C
@@ -0,0 +1,11 @@
+// { dg-do compile { target c++11 } }
+
+#define SA(X) static_assert((X),#X)
+
+void f()
+{
+ int x;
+ auto l = [=]{ return x; };
+ typedef decltype(l) C;
+ SA(__is_nothrow_constructible(C,C));
+}
diff --git a/gcc/testsuite/g++.dg/ext/is_nothrow_constructible5.C b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible5.C
new file mode 100644
index 00000000000..b8471130481
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible5.C
@@ -0,0 +1,12 @@
+// PR c++/80991
+// { dg-do compile { target c++11 } }
+
+template<bool> void foo()
+{
+ static_assert(__is_nothrow_constructible(int, int), "");
+}
+
+void bar()
+{
+ foo<true>();
+}
diff --git a/gcc/testsuite/g++.dg/ext/is_nothrow_constructible6.C b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible6.C
new file mode 100644
index 00000000000..bdfdfb99de2
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/is_nothrow_constructible6.C
@@ -0,0 +1,11 @@
+// { dg-do compile { target c++11 } }
+// PR c++/81589
+
+template <typename k>
+struct z {
+ z() noexcept {
+ k::error;
+ }
+};
+
+int x = __is_nothrow_constructible(z<int>);
diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits
index 9994c9ae3d7..bad92bb8d5a 100644
--- a/libstdc++-v3/include/std/type_traits
+++ b/libstdc++-v3/include/std/type_traits
@@ -963,47 +963,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
"template argument must be a complete class or an unbounded array");
};
- template<bool, typename _Tp, typename... _Args>
- struct __is_nt_constructible_impl
- : public false_type
- { };
-
- template<typename _Tp, typename... _Args>
- struct __is_nt_constructible_impl<true, _Tp, _Args...>
- : public __bool_constant<noexcept(_Tp(std::declval<_Args>()...))>
- { };
-
- template<typename _Tp, typename _Arg>
- struct __is_nt_constructible_impl<true, _Tp, _Arg>
- : public __bool_constant<noexcept(static_cast<_Tp>(std::declval<_Arg>()))>
- { };
-
- template<typename _Tp>
- struct __is_nt_constructible_impl<true, _Tp>
- : public __bool_constant<noexcept(_Tp())>
- { };
-
- template<typename _Tp, size_t _Num>
- struct __is_nt_constructible_impl<true, _Tp[_Num]>
- : public __bool_constant<noexcept(typename remove_all_extents<_Tp>::type())>
- { };
-
-#if __cpp_aggregate_paren_init
- template<typename _Tp, size_t _Num, typename _Arg>
- struct __is_nt_constructible_impl<true, _Tp[_Num], _Arg>
- : public __is_nt_constructible_impl<true, _Tp, _Arg>
- { };
-
- template<typename _Tp, size_t _Num, typename... _Args>
- struct __is_nt_constructible_impl<true, _Tp[_Num], _Args...>
- : public __and_<__is_nt_constructible_impl<true, _Tp, _Args>...>
- { };
-#endif
-
template<typename _Tp, typename... _Args>
using __is_nothrow_constructible_impl
- = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...),
- _Tp, _Args...>;
+ = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>;
/// is_nothrow_constructible
template<typename _Tp, typename... _Args>
@@ -1017,7 +979,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// is_nothrow_default_constructible
template<typename _Tp>
struct is_nothrow_default_constructible
- : public __is_nothrow_constructible_impl<_Tp>::type
+ : public __bool_constant<__is_nothrow_constructible(_Tp)>
{
static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
"template argument must be a complete class or an unbounded array");
@@ -1118,15 +1080,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
};
template<typename _Tp, typename _Up>
- struct __is_nt_assignable_impl
- : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
- { };
-
- template<typename _Tp, typename _Up>
- struct __is_nothrow_assignable_impl
- : public __and_<__bool_constant<__is_assignable(_Tp, _Up)>,
- __is_nt_assignable_impl<_Tp, _Up>>
- { };
+ using __is_nothrow_assignable_impl
+ = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>;
/// is_nothrow_assignable
template<typename _Tp, typename _Up>
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable}
2020-10-23 23:32 [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable} Ville Voutilainen
@ 2020-10-23 23:34 ` Ville Voutilainen
2020-10-24 0:00 ` Marek Polacek
2020-10-26 12:22 ` Jonathan Wakely
2 siblings, 0 replies; 9+ messages in thread
From: Ville Voutilainen @ 2020-10-23 23:34 UTC (permalink / raw)
To: gcc-patches List, libstdc++, Jason Merrill
On Sat, 24 Oct 2020 at 02:32, Ville Voutilainen
<ville.voutilainen@gmail.com> wrote:
> * method.c (__is_nothrow_xible): New.
..and this is is_nothrow_xible, without leading underscores.
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable}
2020-10-23 23:32 [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable} Ville Voutilainen
2020-10-23 23:34 ` Ville Voutilainen
@ 2020-10-24 0:00 ` Marek Polacek
2020-10-24 0:03 ` Ville Voutilainen
2020-10-26 12:22 ` Jonathan Wakely
2 siblings, 1 reply; 9+ messages in thread
From: Marek Polacek @ 2020-10-24 0:00 UTC (permalink / raw)
To: Ville Voutilainen; +Cc: gcc-patches List, libstdc++, Jason Merrill
On Sat, Oct 24, 2020 at 02:32:37AM +0300, Ville Voutilainen via Gcc-patches wrote:
> Finishing testing on Linux-PPC64. Ok for trunk if tests pass?
>
> 2020-10-24 Ville Voutilainen <ville.voutilainen@gmail.com>
>
> gcc/c-family/ChangeLog:
>
> Implement __is_nothrow_{constructible,assignable}
> * c-common.c (__is_nothrow_assignable): New.
> (__is_nothrow_constructible): Likewise.
> * c-common.h (RID_IS_NOTHROW_ASSIGNABLE): New.
> (RID_IS_NOTHROW_CONSTRUCTIBLE): Likewise.
>
> gcc/cp/ChangeLog:
>
> Implement __is_nothrow_{constructible,assignable}
> * cp-tree.h (CPTK_IS_NOTHROW_ASSIGNABLE): New.
> (CPTK_IS_NOTHROW_CONSTRUCTIBLE): Likewise.
> (is_nothrow_xible): Likewise.
> * method.c (__is_nothrow_xible): New.
> * parser.c (cp_parser_primary_expression): Handle the new RID_*.
> (cp_parser_trait_expr): Likewise.
> * semantics.c (trait_expr_value): Handle the new RID_*.
> (finish_trait_expr): Likewise.
>
> libstdc++-v3/ChangeLog:
>
> Implement __is_nothrow_{constructible,assignable}
> * include/std/type_traits (__is_nt_constructible_impl): Remove.
> (__is_nothrow_constructible_impl): Adjust.
> (is_nothrow_default_constructible): Likewise.
> (__is_nt_assignable_impl): Remove.
> (__is_nothrow_assignable_impl): Adjust.
> diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
> index e16ca3894bc..098a36e4d67 100644
> --- a/gcc/c-family/c-common.c
> +++ b/gcc/c-family/c-common.c
> @@ -527,6 +527,8 @@ const struct c_common_resword c_common_reswords[] =
> { "while", RID_WHILE, 0 },
> { "__is_assignable", RID_IS_ASSIGNABLE, D_CXXONLY },
> { "__is_constructible", RID_IS_CONSTRUCTIBLE, D_CXXONLY },
> + { "__is_nothrow_assignable", RID_IS_NOTHROW_ASSIGNABLE, D_CXXONLY },
> + { "__is_nothrow_constructible", RID_IS_NOTHROW_CONSTRUCTIBLE, D_CXXONLY },
>
> /* C++ transactional memory. */
> { "synchronized", RID_SYNCHRONIZED, D_CXX_OBJC | D_TRANSMEM },
> diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
> index 3d96092a297..24a4a8e7fe3 100644
> --- a/gcc/c-family/c-common.h
> +++ b/gcc/c-family/c-common.h
> @@ -176,6 +176,7 @@ enum rid
> RID_IS_TRIVIALLY_COPYABLE,
> RID_IS_UNION, RID_UNDERLYING_TYPE,
> RID_IS_ASSIGNABLE, RID_IS_CONSTRUCTIBLE,
> + RID_IS_NOTHROW_ASSIGNABLE, RID_IS_NOTHROW_CONSTRUCTIBLE,
>
> /* C++11 */
> RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT,
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 5c06ac3789e..1ce20989e13 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -1323,7 +1323,9 @@ enum cp_trait_kind
> CPTK_IS_UNION,
> CPTK_UNDERLYING_TYPE,
> CPTK_IS_ASSIGNABLE,
> - CPTK_IS_CONSTRUCTIBLE
> + CPTK_IS_CONSTRUCTIBLE,
> + CPTK_IS_NOTHROW_ASSIGNABLE,
> + CPTK_IS_NOTHROW_CONSTRUCTIBLE
> };
>
> /* The types that we are processing. */
> @@ -6752,6 +6754,7 @@ extern void use_thunk (tree, bool);
> extern bool trivial_fn_p (tree);
> extern tree forward_parm (tree);
> extern bool is_trivially_xible (enum tree_code, tree, tree);
> +extern bool is_nothrow_xible (enum tree_code, tree, tree);
> extern bool is_xible (enum tree_code, tree, tree);
> extern tree get_defaulted_eh_spec (tree, tsubst_flags_t = tf_warning_or_error);
> extern bool maybe_explain_implicit_delete (tree);
> diff --git a/gcc/cp/method.c b/gcc/cp/method.c
> index 6e4c5f7e83b..2ffc86cbd81 100644
> --- a/gcc/cp/method.c
> +++ b/gcc/cp/method.c
> @@ -1933,6 +1933,21 @@ is_trivially_xible (enum tree_code code, tree to, tree from)
> return !nt;
> }
>
> +/* Returns true iff TO is nothrow assignable (if CODE is MODIFY_EXPR) or
> + constructible (otherwise) from FROM, which is a single type for
> + assignment or a list of types for construction. */
> +
> +bool
> +is_nothrow_xible (enum tree_code code, tree to, tree from)
> +{
> + tree expr;
> + expr = is_xible_helper (code, to, from, /*trivial*/false);
tree expr = is_xible_helper (code, to, from, /*trivial*/false);
would be nicer, otherwise the front-end changes look fine, thanks.
Marek
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable}
2020-10-24 0:00 ` Marek Polacek
@ 2020-10-24 0:03 ` Ville Voutilainen
2020-10-24 0:07 ` Marek Polacek
2020-10-24 1:37 ` Jason Merrill
0 siblings, 2 replies; 9+ messages in thread
From: Ville Voutilainen @ 2020-10-24 0:03 UTC (permalink / raw)
To: Marek Polacek; +Cc: gcc-patches List, libstdc++, Jason Merrill
On Sat, 24 Oct 2020 at 03:00, Marek Polacek <polacek@redhat.com> wrote:
> > + tree expr;
> > + expr = is_xible_helper (code, to, from, /*trivial*/false);
>
> tree expr = is_xible_helper (code, to, from, /*trivial*/false);
>
> would be nicer, otherwise the front-end changes look fine, thanks.
Ha, we have the same thing in is_trivially_xible, so I'll drive-by
change that one as well.
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable}
2020-10-24 0:03 ` Ville Voutilainen
@ 2020-10-24 0:07 ` Marek Polacek
2020-10-24 0:11 ` Ville Voutilainen
2020-10-24 1:37 ` Jason Merrill
1 sibling, 1 reply; 9+ messages in thread
From: Marek Polacek @ 2020-10-24 0:07 UTC (permalink / raw)
To: Ville Voutilainen; +Cc: libstdc++, gcc-patches List
On Sat, Oct 24, 2020 at 03:03:51AM +0300, Ville Voutilainen via Gcc-patches wrote:
> On Sat, 24 Oct 2020 at 03:00, Marek Polacek <polacek@redhat.com> wrote:
> > > + tree expr;
> > > + expr = is_xible_helper (code, to, from, /*trivial*/false);
> >
> > tree expr = is_xible_helper (code, to, from, /*trivial*/false);
> >
> > would be nicer, otherwise the front-end changes look fine, thanks.
>
> Ha, we have the same thing in is_trivially_xible, so I'll drive-by
> change that one as well.
Please. Thanks!
Marek
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable}
2020-10-24 0:07 ` Marek Polacek
@ 2020-10-24 0:11 ` Ville Voutilainen
2020-10-24 15:41 ` Marek Polacek
0 siblings, 1 reply; 9+ messages in thread
From: Ville Voutilainen @ 2020-10-24 0:11 UTC (permalink / raw)
To: Marek Polacek; +Cc: libstdc++, gcc-patches List
On Sat, 24 Oct 2020 at 03:07, Marek Polacek <polacek@redhat.com> wrote:
> > Ha, we have the same thing in is_trivially_xible, so I'll drive-by
> > change that one as well.
>
> Please. Thanks!
The tree is also on a separated line in is_trivially_xible and
is_nothrow_xible, but not
in is_xible. What do we think about line-whitespace changes mixed with
'real' changes?
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable}
2020-10-24 0:03 ` Ville Voutilainen
2020-10-24 0:07 ` Marek Polacek
@ 2020-10-24 1:37 ` Jason Merrill
1 sibling, 0 replies; 9+ messages in thread
From: Jason Merrill @ 2020-10-24 1:37 UTC (permalink / raw)
To: Ville Voutilainen, Marek Polacek; +Cc: gcc-patches List, libstdc++
On 10/23/20 8:03 PM, Ville Voutilainen wrote:
> On Sat, 24 Oct 2020 at 03:00, Marek Polacek <polacek@redhat.com> wrote:
>>> + tree expr;
>>> + expr = is_xible_helper (code, to, from, /*trivial*/false);
>>
>> tree expr = is_xible_helper (code, to, from, /*trivial*/false);
>>
>> would be nicer, otherwise the front-end changes look fine, thanks.
>
> Ha, we have the same thing in is_trivially_xible, so I'll drive-by
> change that one as well.
OK with that change.
Jason
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable}
2020-10-24 0:11 ` Ville Voutilainen
@ 2020-10-24 15:41 ` Marek Polacek
0 siblings, 0 replies; 9+ messages in thread
From: Marek Polacek @ 2020-10-24 15:41 UTC (permalink / raw)
To: Ville Voutilainen; +Cc: libstdc++, gcc-patches List
On Sat, Oct 24, 2020 at 03:11:29AM +0300, Ville Voutilainen wrote:
> On Sat, 24 Oct 2020 at 03:07, Marek Polacek <polacek@redhat.com> wrote:
> > > Ha, we have the same thing in is_trivially_xible, so I'll drive-by
> > > change that one as well.
> >
> > Please. Thanks!
>
> The tree is also on a separated line in is_trivially_xible and
> is_nothrow_xible, but not
> in is_xible. What do we think about line-whitespace changes mixed with
> 'real' changes?
I like to do such cleanups when they are nearby the code I'm changing. In this
case, I think it's totally fine (though I know not everybody feels the same
way). Clearly you wouldn't do cleanups in different source files or 1000 lines
away from where you're making your change.
Marek
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable}
2020-10-23 23:32 [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable} Ville Voutilainen
2020-10-23 23:34 ` Ville Voutilainen
2020-10-24 0:00 ` Marek Polacek
@ 2020-10-26 12:22 ` Jonathan Wakely
2 siblings, 0 replies; 9+ messages in thread
From: Jonathan Wakely @ 2020-10-26 12:22 UTC (permalink / raw)
To: Ville Voutilainen; +Cc: gcc-patches List, libstdc++, Jason Merrill
On 24/10/20 02:32 +0300, Ville Voutilainen via Libstdc++ wrote:
>@@ -1118,15 +1080,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
> };
>
> template<typename _Tp, typename _Up>
>- struct __is_nt_assignable_impl
>- : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
>- { };
>-
>- template<typename _Tp, typename _Up>
>- struct __is_nothrow_assignable_impl
>- : public __and_<__bool_constant<__is_assignable(_Tp, _Up)>,
>- __is_nt_assignable_impl<_Tp, _Up>>
>- { };
>+ using __is_nothrow_assignable_impl
>+ = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>;
Please indent the "= __bool_constant<...>;" line two more spaces,
rather than lining it up with the "using".
The library changes are OK with that tweak. Thanks!
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2020-10-26 12:22 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-10-23 23:32 [PATCH] g++, libstdc++: implement __is_nothrow_{constructible, assignable} Ville Voutilainen
2020-10-23 23:34 ` Ville Voutilainen
2020-10-24 0:00 ` Marek Polacek
2020-10-24 0:03 ` Ville Voutilainen
2020-10-24 0:07 ` Marek Polacek
2020-10-24 0:11 ` Ville Voutilainen
2020-10-24 15:41 ` Marek Polacek
2020-10-24 1:37 ` Jason Merrill
2020-10-26 12:22 ` 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).