On Fri, 30 May 2025, Nathaniel Shead wrote:
> On Wed, May 28, 2025 at 02:14:06PM -0400, Patrick Palka wrote:
> > On Tue, 27 May 2025, Nathaniel Shead wrote:
> >
> > > On Wed, Nov 27, 2024 at 11:45:40AM -0500, Patrick Palka wrote:
> > > > On Fri, 8 Nov 2024, Nathaniel Shead wrote:
> > > >
> > > > > Does this approach seem reasonable? I'm pretty sure that the way I've
> > > > > handled the templating here is unideal but I'm not sure what a neat
> > > > > way
> > > > > to do what I'm trying to do here would be; any comments are welcome.
> > > >
> > > > Clever approach, I like it!
> > > >
> > > > >
> > > > > -- >8 --
> > > > >
> > > > > Currently, concept failures of standard type traits just report
> > > > > 'expression X<T> evaluates to false'. However, many type traits are
> > > > > actually defined in terms of compiler builtins; we can do better here.
> > > > > For instance, 'is_constructible_v' could go on to explain why the type
> > > > > is not constructible, or 'is_invocable_v' could list potential
> > > > > candidates.
> > > >
> > > > That'd be great improvement.
> > > >
> > > > >
> > > > > As a first step to supporting that we need to be able to map the
> > > > > standard type traits to the builtins that they use. Rather than
> > > > > adding
> > > > > another list that would need to be kept up-to-date whenever a builtin
> > > > > is
> > > > > added, this patch instead tries to detect any variable template
> > > > > defined
> > > > > directly in terms of a TRAIT_EXPR.
> > > > >
> > > > > To avoid false positives, we ignore any variable templates that have
> > > > > any
> > > > > specialisations (partial or explicit), even if we wouldn't have chosen
> > > > > that specialisation anyway. This shouldn't affect any of the standard
> > > > > library type traits that I could see.
> > > >
> > > > You should be able to tsubst the TEMPLATE_ID_EXPR directly and look at
> > > > its TI_PARTIAL_INFO in order to determine which (if any) partial
> > > > specialization was selected. And if an explicit specialization was
> > > > selected the resulting VAR_DECL will have DECL_TEMPLATE_SPECIALIZATION
> > > > set.
> > > >
> > > > > ...[snip]...
> > > >
> > > > If we substituted the TEMPLATE_ID_EXPR as a whole we could use the
> > > > DECL_TI_ARGS of that IIUC?
> > > >
> > >
> > > Thanks for your comments, they were very helpful. Here's a totally new
> > > approach which I'm much happier with. I've also removed the "disable in
> > > case any specialisation exists" logic, as on further reflection I don't
> > > imagine this to be the kind of issue I thought it might have been.
> > >
> > > With this patch,
> > >
> > > template <typename T>
> > > constexpr bool is_default_constructible_v = __is_constructible(T);
> > >
> > > template <typename T>
> > > concept default_constructible = is_default_constructible_v<T>;
> > >
> > > static_assert(default_constructible<void>);
> > >
> > > now emits the following error:
> > >
> > > test.cpp:6:15: error: static assertion failed
> > > 6 | static_assert(default_constructible<void>);
> > > | ^~~~~~~~~~~~~~~~~~~~~~~~~~~
> > > test.cpp:6:15: note: constraints not satisfied
> > > test.cpp:4:9: required by the constraints of ‘template<class T>
> > > concept default_constructible’
> > > test.cpp:4:33: note: ‘void’ is not default constructible
> > > 4 | concept default_constructible = is_default_constructible_v<T>;
> > > | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> > >
> > > There's still a lot of improvements to be made in this area, I think:
> > >
> > > - I haven't yet looked into updating the specific diagnostics emitted by
> > > the traits; I'd like to try to avoid too much code duplication with
> > > the implementation in cp/semantics.cc. (I also don't think the manual
> > > indentation at the start of the message is particularly helpful?)
> >
> > For is_xible / is_convertible etc, perhaps they could use a 'complain'
> > parameter that they propagate through instead of always passing tf_none,
> > similar to build_invoke? Then we can call those predicates directly
> > from diagnose_trait_expr with complain=tf_error so that they elaborate
> > why they failed.
> >
>
> Done; for is_xible I ended up slightly preferring a 'bool explain'
> (since it doesn't really make sense to talk about "complaining" for a
> predicate?) but happy to swap over if that's more consistent.
>
> > Agreed about the extra indentation
> >
> > >
> > > - The message doesn't print the mapping '[with T = void]'; I tried a
> > > couple of things but this doesn't currently look especially
> > > straight-forward, as we don't currently associate the args with the
> > > normalised atomic constraint of the declaration.
> >
> > Maybe we can still print the
> >
> > note: the expression ‘normal<T> [with T = void]’ evaluated to ‘false’
> >
> > note alongside the extended diagnostics? Which would mean moving the
> > maybe_diagnose_standard_trait call a bit lower in
> > diagnose_atomic_constraint.
> >
> > This would arguably make the diagnostic even noiser, but IMHO the
> > parameter mapping is an important piece of information to omit.
> >
>
> Agreed, can always look at condensing things later but I think this is a
> good improvement.
>
> > >
> > > - Just generally I think there's still a lot of noise in the diagnostic,
> > > and I find the back-to-front ordering of 'required by...' confusing.
> >
> > Agreed in general, but in the case of these type trait diagnostics I
> > think noisiness is kind of inevitable especially if we start explaining
> > in detail why the trait is unsatisified (as e.g. PR117294 requests).
> >
>
> Thanks for your comments! With this patch, the following example:
>
> #include <type_traits>
> #include <concepts>
> struct S {
> S(int);
> };
> static_assert(std::is_nothrow_constructible_v<S, int>);
> template <std::regular T> void foo(T t);
> int main() {
> foo(S{});
> }
>
> with '-fdiagnostics-set-output=text:experimental-nesting=yes' now emits:
>
> test.cpp:6:20: error: static assertion failed
> 6 | static_assert(std::is_nothrow_constructible_v<S, int>);
> | ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> • ‘S’ is not nothrow constructible from ‘int’, because
> • ‘S::S(int)’ is not ‘noexcept’
> test.cpp:4:3:
> 4 | S(int);
> | ^
> test.cpp: In function ‘int main()’:
> test.cpp:9:6: error: no matching function for call to ‘foo(S)’
> 9 | foo(S{123});
> | ~~~^~~~~~~~
> • there is 1 candidate
> • candidate 1: ‘template<class T> requires regular<T> void foo(T)’
> test.cpp:7:32:
> 7 | template <std::regular T> void foo(T t);
> | ^~~
> • template argument deduction/substitution failed:
> • constraints not satisfied
> In file included from test.cpp:2:
> • /home/wreien/.local/include/c++/16.0.0/concepts: In substitution
> of ‘template<class T> requires regular<T> void foo(T) [with T = S]’:
> • required from here
> test.cpp:9:6:
> 9 | foo(S{123});
> | ~~~^~~~~~~~
> • required for the satisfaction of ‘constructible_from<_Tp>’ [with
> _Tp = S]
> /home/wreien/.local/include/c++/16.0.0/concepts:161:13:
> 161 | concept constructible_from
> | ^~~~~~~~~~~~~~~~~~
> • required for the satisfaction of ‘default_initializable<_Tp>’
> [with _Tp = S]
> /home/wreien/.local/include/c++/16.0.0/concepts:166:13:
> 166 | concept default_initializable =
> constructible_from<_Tp>
> | ^~~~~~~~~~~~~~~~~~~~~
> • required for the satisfaction of ‘semiregular<_Tp>’ [with _Tp = S]
> /home/wreien/.local/include/c++/16.0.0/concepts:282:13:
> 282 | concept semiregular = copyable<_Tp> &&
> default_initializable<_Tp>;
> | ^~~~~~~~~~~
> • required for the satisfaction of ‘regular<T>’ [with T = S]
> /home/wreien/.local/include/c++/16.0.0/concepts:356:13:
> 356 | concept regular = semiregular<_Tp> &&
> equality_comparable<_Tp>;
> | ^~~~~~~
> • the expression ‘is_constructible_v<_Tp, _Args ...> [with _Tp = S;
> _Args = {}]’ evaluated to ‘false’
> /home/wreien/.local/include/c++/16.0.0/concepts:162:30:
> 162 | = destructible<_Tp> && is_constructible_v<_Tp,
> _Args...>;
> |
> ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> • ‘S’ is not default constructible, because
> • error: no matching function for call to ‘S::S()’
> • there are 3 candidates
> • candidate 1: ‘S::S(int)’
> test.cpp:4:3:
> 4 | S(int);
> | ^
> • candidate expects 1 argument, 0 provided
> • candidate 2: ‘constexpr S::S(const S&)’
> test.cpp:3:8:
> 3 | struct S {
> | ^
> • candidate expects 1 argument, 0 provided
> • candidate 3: ‘constexpr S::S(S&&)’
> • candidate expects 1 argument, 0 provided
Awesome, I think users will like this very much!
>
> Bootstrapped and regtested on x86_64-pc-linux-gnu, OK for trunk?
>
> -- >8 --
>
> Currently, concept failures of standard type traits just report
> 'expression X<T> evaluates to false'. However, many type traits are
> actually defined in terms of compiler builtins; we can do better here.
> For instance, 'is_constructible_v' could go on to explain why the type
> is not constructible, or 'is_invocable_v' could list potential
> candidates.
>
> Apart from concept diagnostics, this is also useful when using such
> traits in a 'static_assert' directly, so this patch also adjusts the
> diagnostics in that context.
>
> As a first step to supporting that we need to be able to map the
> standard type traits to the builtins that they use. Rather than adding
> another list that would need to be kept up-to-date whenever a builtin is
> added, this patch instead tries to detect any variable template defined
> directly in terms of a TRAIT_EXPR.
>
> This patch also adjusts 'diagnose_trait_expr' to provide more helpful
> diagnostics for these cases. Not all type traits have yet been updated,
> this patch just updates those that seem particularly valuable or
> straight-forward. The function also gets moved to cp/semantics.cc to be
> closer to 'trait_expr_value'.
>
> Various other parts of the compiler are also adjusted here to assist in
> making clear diagnostics, such as making more use of 'is_stub_object' to
> refer to a type directly rather than in terms of 'std::declval<T>()'.
> Additionally, since there are now more cases of nesting within a
> 'static_assert'ion I felt it was helpful for the experimental-nesting
> mode to nest here as well.
>
> PR c++/117294
> PR c++/113854
>
> gcc/cp/ChangeLog:
>
> * call.cc (implicit_conversion_error): Hide label when printing
> a stub object.
> (convert_like_internal): Likewise, and nest candidate
> diagnostics.
> * constexpr.cc (diagnose_failing_condition): Nest diagnostics,
> attempt to provide more helpful diagnostics for traits.
> * constraint.cc (diagnose_trait_expr): Move to semantics.cc.
> (diagnose_atomic_constraint): Attempt to provide more helpful
> diagnostics for more traits.
> * cp-tree.h (explain_not_noexcept): Declare new function.
> (is_trivially_xible): Add parameter.
> (is_nothrow_xible): Likewise.
> (is_xible): Likewise.
> (is_convertible): Likewise.
> (is_nothrow_convertible): Likewise.
> (maybe_diagnose_standard_trait): Declare new function.
> * error.cc (dump_type) <case TREE_VEC>: Handle trait types.
> * except.cc (explain_not_noexcept): New function.
> * method.cc (build_trait_object): Add complain parameter.
> (assignable_expr): Add explain parameter to show diagnostics.
> (constructible_expr): Likewise.
> (destructible_expr): Likewise.
> (is_xible_helper): Replace trivial flag with explain flag,
> add diagnostics.
> (is_trivially_xible): New explain flag.
> (is_nothrow_xible): Likewise.
> (is_xible): Likewise.
> (is_convertible_helper): Add complain flag.
> (is_convertible): New explain flag.
> (is_nothrow_convertible): Likewise.
> * semantics.cc (diagnose_trait_expr): Move from constrain.cc.
> Adjust diagnostics for clarity and detail.
> (maybe_diagnose_standard_trait): New function.
> * typeck.cc (cp_build_function_call_vec): Add handling for stub
> objects.
> (convert_arguments): Always return -1 on error.
> * typeck2.cc (cxx_readonly_error): Add handling for stub
> objects.
>
> libstdc++-v3/ChangeLog:
>
> * testsuite/20_util/any/misc/any_cast_neg.cc: Adjust
> diagnostics.
> * testsuite/20_util/expected/illformed_neg.cc: Likewise.
> * testsuite/20_util/optional/monadic/or_else_neg.cc: Likewise.
> * testsuite/23_containers/array/creation/3_neg.cc: Likewise.
> * testsuite/24_iterators/range_generators/lwg3900.cc: Likewise.
> * testsuite/29_atomics/atomic/requirements/types_neg.cc:
> Likewise.
> * testsuite/30_threads/stop_token/stop_callback/invocable_neg.cc:
> Likewise.
> * testsuite/std/format/arguments/args_neg.cc: Likewise.
> * testsuite/std/format/string_neg.cc: Likewise.
>
> gcc/testsuite/ChangeLog:
>
> * g++.dg/cpp2a/concepts-traits3.C: Adjust diagnostics.
> * g++.dg/cpp2a/concepts-traits4.C: New test.
> * g++.dg/diagnostic/static_assert5.C: New test.
> * g++.dg/ext/has_virtual_destructor2.C: New test.
> * g++.dg/ext/is_assignable2.C: New test.
> * g++.dg/ext/is_constructible9.C: New test.
> * g++.dg/ext/is_convertible7.C: New test.
> * g++.dg/ext/is_destructible2.C: New test.
> * g++.dg/ext/is_invocable5.C: New test.
> * g++.dg/ext/is_virtual_base_of_diagnostic2.C: New test.
>
> Signed-off-by: Nathaniel Shead <nathanielosh...@gmail.com>
> Reviewed-by: Patrick Palka <ppa...@redhat.com>
> ---
> gcc/cp/call.cc | 20 +-
> gcc/cp/constexpr.cc | 5 +
> gcc/cp/constraint.cc | 249 +--------------
> gcc/cp/cp-tree.h | 15 +-
> gcc/cp/error.cc | 14 +
> gcc/cp/except.cc | 12 +
> gcc/cp/method.cc | 194 ++++++++----
> gcc/cp/semantics.cc | 297 ++++++++++++++++++
> gcc/cp/typeck.cc | 14 +-
> gcc/cp/typeck2.cc | 5 +
> gcc/testsuite/g++.dg/cpp2a/concepts-traits3.C | 31 +-
> gcc/testsuite/g++.dg/cpp2a/concepts-traits4.C | 77 +++++
> .../g++.dg/diagnostic/static_assert5.C | 70 +++++
> .../g++.dg/ext/has_virtual_destructor2.C | 27 ++
> gcc/testsuite/g++.dg/ext/is_assignable2.C | 36 +++
> gcc/testsuite/g++.dg/ext/is_constructible9.C | 60 ++++
> gcc/testsuite/g++.dg/ext/is_convertible7.C | 29 ++
> gcc/testsuite/g++.dg/ext/is_destructible2.C | 48 +++
> gcc/testsuite/g++.dg/ext/is_invocable5.C | 41 +++
> .../ext/is_virtual_base_of_diagnostic2.C | 13 +
> .../20_util/any/misc/any_cast_neg.cc | 3 +
> .../20_util/expected/illformed_neg.cc | 1 +
> .../20_util/optional/monadic/or_else_neg.cc | 1 +
> .../23_containers/array/creation/3_neg.cc | 2 +
> .../24_iterators/range_generators/lwg3900.cc | 3 +-
> .../atomic/requirements/types_neg.cc | 2 +
> .../stop_token/stop_callback/invocable_neg.cc | 1 +
> .../std/format/arguments/args_neg.cc | 1 +
> .../testsuite/std/format/string_neg.cc | 2 +
> 29 files changed, 955 insertions(+), 318 deletions(-)
> create mode 100644 gcc/testsuite/g++.dg/cpp2a/concepts-traits4.C
> create mode 100644 gcc/testsuite/g++.dg/diagnostic/static_assert5.C
> create mode 100644 gcc/testsuite/g++.dg/ext/has_virtual_destructor2.C
> create mode 100644 gcc/testsuite/g++.dg/ext/is_assignable2.C
> create mode 100644 gcc/testsuite/g++.dg/ext/is_constructible9.C
> create mode 100644 gcc/testsuite/g++.dg/ext/is_convertible7.C
> create mode 100644 gcc/testsuite/g++.dg/ext/is_destructible2.C
> create mode 100644 gcc/testsuite/g++.dg/ext/is_invocable5.C
> create mode 100644 gcc/testsuite/g++.dg/ext/is_virtual_base_of_diagnostic2.C
>
> diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
> index 2c3ef3dfc35..f5b39e403c5 100644
> --- a/gcc/cp/call.cc
> +++ b/gcc/cp/call.cc
> @@ -4876,6 +4876,11 @@ implicit_conversion_error (location_t loc, tree type,
> tree expr)
> && !CP_AGGREGATE_TYPE_P (type))
> error_at (loc, "designated initializers cannot be used with a "
> "non-aggregate type %qT", type);
> + else if (is_stub_object (expr))
> + /* The expression is generated by a trait check, we don't have
> + a useful location to highlight the label. */
> + error_at (loc, "could not convert %qH to %qI",
> + TREE_TYPE (expr), type);
> else
> {
> range_label_for_type_mismatch label (TREE_TYPE (expr), type);
> @@ -8645,6 +8650,7 @@ convert_like_internal (conversion *convs, tree expr,
> tree fn, int argnum,
> diagnostic_t diag_kind;
> int flags;
> location_t loc = cp_expr_loc_or_input_loc (expr);
> + const bool stub_object_p = is_stub_object (expr);
>
> if (convs->bad_p && !(complain & tf_error))
> return error_mark_node;
> @@ -8721,7 +8727,10 @@ convert_like_internal (conversion *convs, tree expr,
> tree fn, int argnum,
> "from %qH to %qI", TREE_TYPE (expr),
> totype);
> if (complained)
> - print_z_candidate (loc, N_("candidate is:"), t->cand);
> + {
> + auto_diagnostic_nesting_level sentinel;
> + print_z_candidate (loc, N_("candidate is:"), t->cand);
> + }
> expr = convert_like (t, expr, fn, argnum,
> /*issue_conversion_warnings=*/false,
> /*c_cast_p=*/false, /*nested_p=*/true,
> @@ -8746,7 +8755,14 @@ convert_like_internal (conversion *convs, tree expr,
> tree fn, int argnum,
> else if (t->kind == ck_identity)
> break;
> }
> - if (!complained && expr != error_mark_node)
> + if (!complained && stub_object_p)
> + {
> + /* An error diagnosed within a trait, don't give extra labels. */
> + error_at (loc, "invalid conversion from %qH to %qI",
> + TREE_TYPE (expr), totype);
> + complained = 1;
> + }
> + else if (!complained && expr != error_mark_node)
> {
> range_label_for_type_mismatch label (TREE_TYPE (expr), totype);
> gcc_rich_location richloc (loc, &label, highlight_colors::percent_h);
> diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc
> index fa754b9a176..95b7f385dbf 100644
> --- a/gcc/cp/constexpr.cc
> +++ b/gcc/cp/constexpr.cc
> @@ -2122,10 +2122,15 @@ diagnose_failing_condition (tree bad, location_t
> cloc, bool show_expr_p,
> if (TREE_CODE (bad) == CLEANUP_POINT_EXPR)
> bad = TREE_OPERAND (bad, 0);
>
> + auto_diagnostic_nesting_level sentinel;
> +
> /* Actually explain the failure if this is a concept check or a
> requires-expression. */
> if (concept_check_p (bad) || TREE_CODE (bad) == REQUIRES_EXPR)
> diagnose_constraints (cloc, bad, NULL_TREE);
> + /* Similarly if this is a standard trait. */
> + else if (maybe_diagnose_standard_trait (cloc, bad, NULL_TREE))
> + ;
> else if (COMPARISON_CLASS_P (bad)
> && ARITHMETIC_TYPE_P (TREE_TYPE (TREE_OPERAND (bad, 0))))
> {
> diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc
> index 90625707043..bb32c8ab111 100644
> --- a/gcc/cp/constraint.cc
> +++ b/gcc/cp/constraint.cc
> @@ -3013,233 +3013,6 @@ get_constraint_error_location (tree t)
> return input_location;
> }
>
> -/* Emit a diagnostic for a failed trait. */
> -
> -static void
> -diagnose_trait_expr (tree expr, tree args)
> -{
> - location_t loc = cp_expr_location (expr);
> -
> - /* Build a "fake" version of the instantiated trait, so we can
> - get the instantiated types from result. */
> - ++processing_template_decl;
> - expr = tsubst_expr (expr, args, tf_none, NULL_TREE);
> - --processing_template_decl;
> -
> - tree t1 = TRAIT_EXPR_TYPE1 (expr);
> - tree t2 = TRAIT_EXPR_TYPE2 (expr);
> - if (t2 && TREE_CODE (t2) == TREE_VEC)
> - {
> - /* Convert the TREE_VEC of arguments into a TREE_LIST, since we can't
> - directly print a TREE_VEC but we can a TREE_LIST via the E format
> - specifier. */
> - tree list = NULL_TREE;
> - for (tree t : tree_vec_range (t2))
> - list = tree_cons (NULL_TREE, t, list);
> - t2 = nreverse (list);
> - }
> - switch (TRAIT_EXPR_KIND (expr))
> - {
> - case CPTK_HAS_NOTHROW_ASSIGN:
> - inform (loc, " %qT is not nothrow copy assignable", t1);
> - break;
> - case CPTK_HAS_NOTHROW_CONSTRUCTOR:
> - inform (loc, " %qT is not nothrow default constructible", t1);
> - break;
> - case CPTK_HAS_NOTHROW_COPY:
> - inform (loc, " %qT is not nothrow copy constructible", t1);
> - break;
> - case CPTK_HAS_TRIVIAL_ASSIGN:
> - inform (loc, " %qT is not trivially copy assignable", t1);
> - break;
> - case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
> - inform (loc, " %qT is not trivially default constructible", t1);
> - break;
> - case CPTK_HAS_TRIVIAL_COPY:
> - inform (loc, " %qT is not trivially copy constructible", t1);
> - break;
> - case CPTK_HAS_TRIVIAL_DESTRUCTOR:
> - inform (loc, " %qT is not trivially destructible", t1);
> - break;
> - case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS:
> - inform (loc, " %qT does not have unique object representations", t1);
> - break;
> - case CPTK_HAS_VIRTUAL_DESTRUCTOR:
> - inform (loc, " %qT does not have a virtual destructor", t1);
> - break;
> - case CPTK_IS_ABSTRACT:
> - inform (loc, " %qT is not an abstract class", t1);
> - break;
> - case CPTK_IS_AGGREGATE:
> - inform (loc, " %qT is not an aggregate", t1);
> - break;
> - case CPTK_IS_ARRAY:
> - inform (loc, " %qT is not an array", t1);
> - break;
> - case CPTK_IS_ASSIGNABLE:
> - inform (loc, " %qT is not assignable from %qT", t1, t2);
> - break;
> - case CPTK_IS_BASE_OF:
> - inform (loc, " %qT is not a base of %qT", t1, t2);
> - break;
> - case CPTK_IS_BOUNDED_ARRAY:
> - inform (loc, " %qT is not a bounded array", t1);
> - break;
> - case CPTK_IS_CLASS:
> - inform (loc, " %qT is not a class", t1);
> - break;
> - case CPTK_IS_CONST:
> - inform (loc, " %qT is not a const type", t1);
> - break;
> - case CPTK_IS_CONSTRUCTIBLE:
> - if (!t2)
> - inform (loc, " %qT is not default constructible", t1);
> - else
> - inform (loc, " %qT is not constructible from %qE", t1, t2);
> - break;
> - case CPTK_IS_CONVERTIBLE:
> - inform (loc, " %qT is not convertible from %qE", t2, t1);
> - break;
> - case CPTK_IS_DESTRUCTIBLE:
> - inform (loc, " %qT is not destructible", t1);
> - break;
> - case CPTK_IS_EMPTY:
> - inform (loc, " %qT is not an empty class", t1);
> - break;
> - case CPTK_IS_ENUM:
> - inform (loc, " %qT is not an enum", t1);
> - break;
> - case CPTK_IS_FINAL:
> - inform (loc, " %qT is not a final class", t1);
> - break;
> - case CPTK_IS_FUNCTION:
> - inform (loc, " %qT is not a function", t1);
> - break;
> - case CPTK_IS_INVOCABLE:
> - if (!t2)
> - inform (loc, " %qT is not invocable", t1);
> - else
> - inform (loc, " %qT is not invocable by %qE", t1, t2);
> - break;
> - case CPTK_IS_LAYOUT_COMPATIBLE:
> - inform (loc, " %qT is not layout compatible with %qT", t1, t2);
> - break;
> - case CPTK_IS_LITERAL_TYPE:
> - inform (loc, " %qT is not a literal type", t1);
> - break;
> - case CPTK_IS_MEMBER_FUNCTION_POINTER:
> - inform (loc, " %qT is not a member function pointer", t1);
> - break;
> - case CPTK_IS_MEMBER_OBJECT_POINTER:
> - inform (loc, " %qT is not a member object pointer", t1);
> - break;
> - case CPTK_IS_MEMBER_POINTER:
> - inform (loc, " %qT is not a member pointer", t1);
> - break;
> - case CPTK_IS_NOTHROW_ASSIGNABLE:
> - inform (loc, " %qT is not nothrow assignable from %qT", t1, t2);
> - break;
> - case CPTK_IS_NOTHROW_CONSTRUCTIBLE:
> - if (!t2)
> - inform (loc, " %qT is not nothrow default constructible", t1);
> - else
> - inform (loc, " %qT is not nothrow constructible from %qE", t1, t2);
> - break;
> - case CPTK_IS_NOTHROW_CONVERTIBLE:
> - inform (loc, " %qT is not nothrow convertible from %qE", t2, t1);
> - break;
> - case CPTK_IS_NOTHROW_DESTRUCTIBLE:
> - inform (loc, " %qT is not nothrow destructible", t1);
> - break;
> - case CPTK_IS_NOTHROW_INVOCABLE:
> - if (!t2)
> - inform (loc, " %qT is not nothrow invocable", t1);
> - else
> - inform (loc, " %qT is not nothrow invocable by %qE", t1, t2);
> - break;
> - case CPTK_IS_OBJECT:
> - inform (loc, " %qT is not an object type", t1);
> - break;
> - case CPTK_IS_POINTER_INTERCONVERTIBLE_BASE_OF:
> - inform (loc, " %qT is not pointer-interconvertible base of %qT",
> - t1, t2);
> - break;
> - case CPTK_IS_POD:
> - inform (loc, " %qT is not a POD type", t1);
> - break;
> - case CPTK_IS_POINTER:
> - inform (loc, " %qT is not a pointer", t1);
> - break;
> - case CPTK_IS_POLYMORPHIC:
> - inform (loc, " %qT is not a polymorphic type", t1);
> - break;
> - case CPTK_IS_REFERENCE:
> - inform (loc, " %qT is not a reference", t1);
> - break;
> - case CPTK_IS_SAME:
> - inform (loc, " %qT is not the same as %qT", t1, t2);
> - break;
> - case CPTK_IS_SCOPED_ENUM:
> - inform (loc, " %qT is not a scoped enum", t1);
> - break;
> - case CPTK_IS_STD_LAYOUT:
> - inform (loc, " %qT is not an standard layout type", t1);
> - break;
> - case CPTK_IS_TRIVIAL:
> - inform (loc, " %qT is not a trivial type", t1);
> - break;
> - case CPTK_IS_TRIVIALLY_ASSIGNABLE:
> - inform (loc, " %qT is not trivially assignable from %qT", t1, t2);
> - break;
> - case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE:
> - if (!t2)
> - inform (loc, " %qT is not trivially default constructible", t1);
> - else
> - inform (loc, " %qT is not trivially constructible from %qE", t1, t2);
> - break;
> - case CPTK_IS_TRIVIALLY_COPYABLE:
> - inform (loc, " %qT is not trivially copyable", t1);
> - break;
> - case CPTK_IS_TRIVIALLY_DESTRUCTIBLE:
> - inform (loc, " %qT is not trivially destructible", t1);
> - break;
> - case CPTK_IS_UNBOUNDED_ARRAY:
> - inform (loc, " %qT is not an unbounded array", t1);
> - break;
> - case CPTK_IS_UNION:
> - inform (loc, " %qT is not a union", t1);
> - break;
> - case CPTK_IS_VIRTUAL_BASE_OF:
> - inform (loc, " %qT is not a virtual base of %qT", t1, t2);
> - break;
> - case CPTK_IS_VOLATILE:
> - inform (loc, " %qT is not a volatile type", t1);
> - break;
> - case CPTK_RANK:
> - inform (loc, " %qT cannot yield a rank", t1);
> - break;
> - case CPTK_REF_CONSTRUCTS_FROM_TEMPORARY:
> - inform (loc, " %qT is not a reference that binds to a temporary "
> - "object of type %qT (direct-initialization)", t1, t2);
> - break;
> - case CPTK_REF_CONVERTS_FROM_TEMPORARY:
> - inform (loc, " %qT is not a reference that binds to a temporary "
> - "object of type %qT (copy-initialization)", t1, t2);
> - break;
> - case CPTK_IS_DEDUCIBLE:
> - inform (loc, " %qD is not deducible from %qT", t1, t2);
> - break;
> -#define DEFTRAIT_TYPE(CODE, NAME, ARITY) \
> - case CPTK_##CODE:
> -#include "cp-trait.def"
> -#undef DEFTRAIT_TYPE
> - /* Type-yielding traits aren't expressions. */
> - gcc_unreachable ();
> - /* We deliberately omit the default case so that when adding a new
> - trait we'll get reminded (by way of a warning) to handle it here. */
> - }
> -}
> -
> /* Diagnose a substitution failure in the atomic constraint T using ARGS. */
>
> static void
> @@ -3264,25 +3037,23 @@ diagnose_atomic_constraint (tree t, tree args, tree
> result, sat_info info)
> /* Generate better diagnostics for certain kinds of expressions. */
> tree expr = ATOMIC_CONSTR_EXPR (t);
> STRIP_ANY_LOCATION_WRAPPER (expr);
> - switch (TREE_CODE (expr))
> +
> + if (TREE_CODE (expr) == REQUIRES_EXPR)
> {
> - case TRAIT_EXPR:
> - diagnose_trait_expr (expr, args);
> - break;
> - case REQUIRES_EXPR:
> gcc_checking_assert (info.diagnose_unsatisfaction_p ());
> /* Clear in_decl before replaying the substitution to avoid emitting
> seemingly unhelpful "in declaration ..." notes that follow some
> substitution failure error messages. */
> info.in_decl = NULL_TREE;
> tsubst_requires_expr (expr, args, info);
> - break;
> - default:
> - if (!same_type_p (TREE_TYPE (result), boolean_type_node))
> - error_at (loc, "constraint %qE has type %qT, not %<bool%>",
> - t, TREE_TYPE (result));
> - else
> - inform (loc, "the expression %qE evaluated to %<false%>", t);
> + }
> + else if (!same_type_p (TREE_TYPE (result), boolean_type_node))
> + error_at (loc, "constraint %qE has type %qT, not %<bool%>",
> + t, TREE_TYPE (result));
> + else
> + {
> + inform (loc, "the expression %qE evaluated to %<false%>", t);
> + maybe_diagnose_standard_trait (loc, expr, args);
> }
> }
>
> diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
> index 19c0b452d86..89e0d96809e 100644
> --- a/gcc/cp/cp-tree.h
> +++ b/gcc/cp/cp-tree.h
> @@ -7387,6 +7387,7 @@ extern int nothrow_libfn_p
> (const_tree);
> extern void check_handlers (tree);
> extern tree finish_noexcept_expr (tree, tsubst_flags_t);
> extern bool expr_noexcept_p (tree, tsubst_flags_t);
> +extern void explain_not_noexcept (tree);
> extern void perform_deferred_noexcept_checks (void);
> extern bool nothrow_spec_p (const_tree);
> extern bool type_noexcept_p (const_tree);
> @@ -7508,11 +7509,14 @@ extern void finish_thunk (tree);
> 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 bool is_convertible (tree, tree);
> -extern bool is_nothrow_convertible (tree, tree);
> +extern bool is_trivially_xible (enum tree_code, tree,
> tree,
> + bool = false);
> +extern bool is_nothrow_xible (enum tree_code, tree, tree,
> + bool = false);
> +extern bool is_xible (enum tree_code, tree, tree,
> + bool = false);
> +extern bool is_convertible (tree, tree, bool = false);
> +extern bool is_nothrow_convertible (tree, tree, bool = false);
> extern bool ref_xes_from_temporary (tree, tree, bool);
> extern tree get_defaulted_eh_spec (tree, tsubst_flags_t =
> tf_warning_or_error);
> extern bool maybe_explain_implicit_delete (tree);
> @@ -8140,6 +8144,7 @@ extern void finish_static_assert (tree,
> tree, location_t,
> extern tree finish_decltype_type (tree, bool, tsubst_flags_t);
> extern tree fold_builtin_is_corresponding_member (location_t, int, tree *);
> extern tree fold_builtin_is_pointer_inverconvertible_with_class (location_t,
> int, tree *);
> +extern bool maybe_diagnose_standard_trait (location_t, tree, tree);
> extern tree finish_trait_expr (location_t, enum
> cp_trait_kind, tree, tree);
> extern tree finish_trait_type (enum cp_trait_kind,
> tree, tree, tsubst_flags_t);
> extern tree build_lambda_expr (void);
> diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc
> index d52dad3db29..9cf04fa4191 100644
> --- a/gcc/cp/error.cc
> +++ b/gcc/cp/error.cc
> @@ -704,6 +704,20 @@ dump_type (cxx_pretty_printer *pp, tree t, int flags)
> }
> break;
>
> + case TREE_VEC:
> + {
> + /* A list of types used for a trait. */
> + bool need_comma = false;
> + for (tree arg : tree_vec_range (t))
> + {
> + if (need_comma)
> + pp_separate_with_comma (pp);
> + dump_type (pp, arg, flags);
> + need_comma = true;
> + }
> + }
> + break;
> +
Is this needed because of the removed TREE_VEC -> TREE_LIST conversion
in diagnose_trait_expr? I think I'd prefer keep performing that
conversion there, making sure to pass a TREE_LIST version of 't2' to
inform, and leave open the question of how the pretty printer should
handle TREE_VEC.
> case TREE_LIST:
> /* A list of function parms. */
> dump_parameters (pp, t, flags);
> diff --git a/gcc/cp/except.cc b/gcc/cp/except.cc
> index a9d8e2ffb57..3541a59451c 100644
> --- a/gcc/cp/except.cc
> +++ b/gcc/cp/except.cc
> @@ -1202,6 +1202,18 @@ expr_noexcept_p (tree expr, tsubst_flags_t complain)
> return true;
> }
>
> +/* Explain why EXPR is not noexcept. */
> +
> +void explain_not_noexcept (tree expr)
> +{
> + tree fn = cp_walk_tree_without_duplicates (&expr, check_noexcept_r, 0);
> + gcc_assert (fn);
> + if (DECL_P (fn))
> + inform (DECL_SOURCE_LOCATION (fn), "%qD is not %<noexcept%>", fn);
> + else
> + inform (location_of (fn), "%qT is not %<noexcept%>", TREE_TYPE (fn));
> +}
> +
> /* Return true iff SPEC is throw() or noexcept(true). */
>
> bool
> diff --git a/gcc/cp/method.cc b/gcc/cp/method.cc
> index 3a675d9f872..de28fc2fd1e 100644
> --- a/gcc/cp/method.cc
> +++ b/gcc/cp/method.cc
> @@ -1928,8 +1928,8 @@ is_stub_object (tree expr)
>
> /* Build a std::declval<TYPE>() expression and return it. */
>
> -tree
> -build_trait_object (tree type)
> +static tree
> +build_trait_object (tree type, tsubst_flags_t complain = tf_none)
We generally avoid defaulted 'complain' parameters, they make it easy to
forget to propagate 'complain' from the caller.
> {
> /* TYPE can't be a function with cv-/ref-qualifiers: std::declval is
> defined as
> @@ -1942,7 +1942,11 @@ build_trait_object (tree type)
> if (FUNC_OR_METHOD_TYPE_P (type)
> && (type_memfn_quals (type) != TYPE_UNQUALIFIED
> || type_memfn_rqual (type) != REF_QUAL_NONE))
> - return error_mark_node;
> + {
> + if (complain & tf_error)
> + error ("%qT is a qualified function type", type);
> + return error_mark_node;
> + }
>
> return build_stub_object (type);
> }
> @@ -2227,12 +2231,20 @@ check_nontriv (tree *tp, int *, void *)
> /* Return declval<T>() = declval<U>() treated as an unevaluated operand. */
>
> static tree
> -assignable_expr (tree to, tree from)
> +assignable_expr (tree to, tree from, bool explain)
> {
> cp_unevaluated cp_uneval_guard;
> - to = build_trait_object (to);
> - from = build_trait_object (from);
> - tree r = cp_build_modify_expr (input_location, to, NOP_EXPR, from,
> tf_none);
> + tsubst_flags_t complain = explain ? tf_error : tf_none;
> +
> + to = build_trait_object (to, complain);
> + if (to == error_mark_node)
> + return error_mark_node;
> +
> + from = build_trait_object (from, complain);
> + if (from == error_mark_node)
> + return error_mark_node;
> +
> + tree r = cp_build_modify_expr (input_location, to, NOP_EXPR, from,
> complain);
> return r;
> }
>
> @@ -2244,10 +2256,11 @@ assignable_expr (tree to, tree from)
> Return something equivalent in well-formedness and triviality. */
>
> static tree
> -constructible_expr (tree to, tree from)
> +constructible_expr (tree to, tree from, bool explain)
> {
> tree expr;
> cp_unevaluated cp_uneval_guard;
> + tsubst_flags_t complain = explain ? tf_error : tf_none;
> const int len = TREE_VEC_LENGTH (from);
> if (CLASS_TYPE_P (to))
> {
> @@ -2257,14 +2270,14 @@ constructible_expr (tree to, tree from)
> to = cp_build_reference_type (to, /*rval*/false);
> tree ob = build_stub_object (to);
> if (len == 0)
> - expr = build_value_init (ctype, tf_none);
> + expr = build_value_init (ctype, complain);
> else
> {
> vec_alloc (args, len);
> for (tree arg : tree_vec_range (from))
> args->quick_push (build_stub_object (arg));
> expr = build_special_member_call (ob, complete_ctor_identifier, &args,
> - ctype, LOOKUP_NORMAL, tf_none);
> + ctype, LOOKUP_NORMAL, complain);
> }
> if (expr == error_mark_node)
> return error_mark_node;
> @@ -2274,7 +2287,7 @@ constructible_expr (tree to, tree from)
> {
> tree dtor = build_special_member_call (ob, complete_dtor_identifier,
> NULL, ctype, LOOKUP_NORMAL,
> - tf_none);
> + complain);
> if (dtor == error_mark_node)
> return error_mark_node;
> if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (ctype))
> @@ -2284,12 +2297,15 @@ constructible_expr (tree to, tree from)
> else
> {
> if (len == 0)
> - return build_value_init (strip_array_types (to), tf_none);
> + return build_value_init (strip_array_types (to), complain);
> if (len > 1)
> {
> if (cxx_dialect < cxx20)
> - /* Too many initializers. */
> - return error_mark_node;
> + {
> + if (explain)
> + error ("too many initializers for non-class type %qT", to);
> + return error_mark_node;
> + }
>
> /* In C++20 this is well-formed:
> using T = int[2];
> @@ -2310,9 +2326,11 @@ constructible_expr (tree to, tree from)
> }
> else
> from = build_stub_object (TREE_VEC_ELT (from, 0));
> +
> + tree orig_from = from;
> expr = perform_direct_initialization_if_possible (to, from,
> /*cast*/false,
> - tf_none);
> + complain);
> /* If t(e) didn't work, maybe t{e} will. */
> if (expr == NULL_TREE
> && len == 1
> @@ -2324,7 +2342,24 @@ constructible_expr (tree to, tree from)
> CONSTRUCTOR_IS_PAREN_INIT (from) = true;
> expr = perform_direct_initialization_if_possible (to, from,
> /*cast*/false,
> - tf_none);
> + complain);
> + }
> +
> + if (expr == NULL_TREE && explain)
> + {
> + if (len > 1)
> + error ("too many initializers for non-class type %qT", to);
> + else
> + {
> + /* Redo the implicit conversion for diagnostics. */
> + int count = errorcount + warningcount;
> + perform_implicit_conversion_flags (to, orig_from, complain,
> + LOOKUP_NORMAL);
> + if (count == errorcount + warningcount)
> + /* The message may have been suppressed due to -w +
> -fpermissive,
> + emit a generic response instead. */
> + error ("the conversion is invalid");
> + }
> }
> }
> return expr;
> @@ -2333,82 +2368,118 @@ constructible_expr (tree to, tree from)
> /* Return declval<T>().~T() treated as an unevaluated operand. */
>
> static tree
> -destructible_expr (tree to)
> +destructible_expr (tree to, bool explain)
> {
> cp_unevaluated cp_uneval_guard;
> + tsubst_flags_t complain = explain ? tf_error : tf_none;
> int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
> - to = build_trait_object (to);
> + to = build_trait_object (to, complain);
> tree r = build_delete (input_location, TREE_TYPE (to), to,
> - sfk_complete_destructor, flags, 0, tf_none);
> + sfk_complete_destructor, flags, 0, complain);
> return r;
> }
>
> /* Returns a tree 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. */
> + assignment or a list of types for construction. If EXPLAIN is
> + set, emit a diagnostic explaining why the operation failed. */
>
> static tree
> -is_xible_helper (enum tree_code code, tree to, tree from, bool trivial)
> +is_xible_helper (enum tree_code code, tree to, tree from, bool explain)
> {
> to = complete_type (to);
> deferring_access_check_sentinel acs (dk_no_deferred);
> - if (VOID_TYPE_P (to) || ABSTRACT_CLASS_TYPE_P (to)
> - || (from && FUNC_OR_METHOD_TYPE_P (from)
> - && (TYPE_READONLY (from) || FUNCTION_REF_QUALIFIED (from))))
> - return error_mark_node;
> +
> + if (!COMPLETE_TYPE_P (to))
> + {
> + if (explain)
> + error_at (location_of (to), "%qT is incomplete", to);
> + return error_mark_node;
> + }
> + if (ABSTRACT_CLASS_TYPE_P (to))
> + {
> + if (explain)
> + error_at (location_of (to), "%qT is abstract", to);
> + return error_mark_node;
> + }
> + if (from
> + && FUNC_OR_METHOD_TYPE_P (from)
> + && (TYPE_READONLY (from) || FUNCTION_REF_QUALIFIED (from)))
> + {
> + if (explain)
> + error ("%qT is a qualified function type", from);
> + return error_mark_node;
> + }
> +
> tree expr;
> if (code == MODIFY_EXPR)
> - expr = assignable_expr (to, from);
> + expr = assignable_expr (to, from, explain);
> else if (code == BIT_NOT_EXPR)
> - expr = destructible_expr (to);
> - else if (trivial && TREE_VEC_LENGTH (from) > 1
> - && cxx_dialect < cxx20)
> - return error_mark_node; // only 0- and 1-argument ctors can be trivial
> - // before C++20 aggregate paren init
> + expr = destructible_expr (to, explain);
> else if (TREE_CODE (to) == ARRAY_TYPE && !TYPE_DOMAIN (to))
> - return error_mark_node; // can't construct an array of unknown bound
> + {
> + if (explain)
> + error ("cannot construct an array of unknown bound");
> + return error_mark_node;
> + }
> else
> - expr = constructible_expr (to, from);
> + expr = constructible_expr (to, from, explain);
> return expr;
> }
>
> /* Returns true iff TO is trivially 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. */
> + assignment or a list of types for construction. If EXPLAIN, diagnose
> + why we returned false. */
>
> bool
> -is_trivially_xible (enum tree_code code, tree to, tree from)
> +is_trivially_xible (enum tree_code code, tree to, tree from,
> + bool explain/*=false*/)
IMHO these defaulted explain parameters are fine since they're
specialized predicates that will only have a handful of callers,
unlike build_trait_object.
> {
> - tree expr = is_xible_helper (code, to, from, /*trivial*/true);
> + tree expr = is_xible_helper (code, to, from, explain);
> if (expr == NULL_TREE || expr == error_mark_node)
> return false;
> tree nt = cp_walk_tree_without_duplicates (&expr, check_nontriv, NULL);
> + if (explain)
> + {
> + gcc_assert (nt);
> + inform (location_of (nt), "%qE is non-trivial", nt);
> + }
> 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. */
> + assignment or a list of types for construction. If EXPLAIN, diagnose
> + why we returned false. */
>
> bool
> -is_nothrow_xible (enum tree_code code, tree to, tree from)
> +is_nothrow_xible (enum tree_code code, tree to, tree from,
> + bool explain/*=false*/)
> {
> ++cp_noexcept_operand;
> - tree expr = is_xible_helper (code, to, from, /*trivial*/false);
> + tree expr = is_xible_helper (code, to, from, explain);
> --cp_noexcept_operand;
> if (expr == NULL_TREE || expr == error_mark_node)
> return false;
> - return expr_noexcept_p (expr, tf_none);
> + bool is_noexcept = expr_noexcept_p (expr, tf_none);
> + if (explain)
> + {
> + gcc_assert (!is_noexcept);
> + explain_not_noexcept (expr);
> + }
> + return is_noexcept;
> }
>
> /* 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. */
> + assignment or a list of types for construction. If EXPLAIN, diagnose
> + why we returned false. */
>
> bool
> -is_xible (enum tree_code code, tree to, tree from)
> +is_xible (enum tree_code code, tree to, tree from, bool explain/*=false*/)
> {
> - tree expr = is_xible_helper (code, to, from, /*trivial*/false);
> + tree expr = is_xible_helper (code, to, from, explain);
> if (expr == error_mark_node)
> return false;
> return !!expr;
> @@ -2442,25 +2513,36 @@ ref_xes_from_temporary (tree to, tree from, bool
> direct_init_p)
> }
>
> /* Worker for is_{,nothrow_}convertible. Attempt to perform an implicit
> - conversion from FROM to TO and return the result. */
> + conversion from FROM to TO and return the result. If EXPLAIN, emit a
> + diagnostic about why the conversion failed. */
>
> static tree
> -is_convertible_helper (tree from, tree to)
> +is_convertible_helper (tree from, tree to, bool explain)
> {
> if (VOID_TYPE_P (from) && VOID_TYPE_P (to))
> return integer_one_node;
> cp_unevaluated u;
> - tree expr = build_trait_object (from);
> + tsubst_flags_t complain = explain ? tf_error : tf_none;
> +
> /* std::is_{,nothrow_}convertible test whether the imaginary function
> definition
>
> To test() { return std::declval<From>(); }
>
> is well-formed. A function can't return a function. */
> - if (FUNC_OR_METHOD_TYPE_P (to) || expr == error_mark_node)
> + if (FUNC_OR_METHOD_TYPE_P (to))
> + {
> + if (explain)
> + error ("%qT is a function type", to);
> + return error_mark_node;
> + }
> +
> + tree expr = build_trait_object (from, complain);
> + if (expr == error_mark_node)
> return error_mark_node;
> +
> deferring_access_check_sentinel acs (dk_no_deferred);
> - return perform_implicit_conversion (to, expr, tf_none);
> + return perform_implicit_conversion (to, expr, complain);
> }
>
> /* Return true if FROM can be converted to TO using implicit conversions,
> @@ -2469,9 +2551,9 @@ is_convertible_helper (tree from, tree to)
> to either type" restriction. */
>
> bool
> -is_convertible (tree from, tree to)
> +is_convertible (tree from, tree to, bool explain/*=false*/)
> {
> - tree expr = is_convertible_helper (from, to);
> + tree expr = is_convertible_helper (from, to, explain);
> if (expr == error_mark_node)
> return false;
> return !!expr;
> @@ -2480,12 +2562,18 @@ is_convertible (tree from, tree to)
> /* Like is_convertible, but the conversion is also noexcept. */
>
> bool
> -is_nothrow_convertible (tree from, tree to)
> +is_nothrow_convertible (tree from, tree to, bool explain/*=false*/)
> {
> - tree expr = is_convertible_helper (from, to);
> + tree expr = is_convertible_helper (from, to, explain);
> if (expr == NULL_TREE || expr == error_mark_node)
> return false;
> - return expr_noexcept_p (expr, tf_none);
> + bool is_noexcept = expr_noexcept_p (expr, tf_none);
> + if (explain)
> + {
> + gcc_assert (!is_noexcept);
> + explain_not_noexcept (expr);
> + }
> + return is_noexcept;
> }
>
> /* Categorize various special_function_kinds. */
> diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
> index 241f2730878..bb537bef05e 100644
> --- a/gcc/cp/semantics.cc
> +++ b/gcc/cp/semantics.cc
> @@ -13426,6 +13426,303 @@ trait_expr_value (cp_trait_kind kind, tree type1,
> tree type2)
> gcc_unreachable ();
> }
>
> +/* Emit a diagnostic for a failed trait. */
> +
> +static void
> +diagnose_trait_expr (location_t loc, tree expr, tree args)
> +{
> + /* Build a "fake" version of the instantiated trait, so we can
> + get the instantiated types from result. */
> + ++processing_template_decl;
> + expr = tsubst_expr (expr, args, tf_none, NULL_TREE);
> + --processing_template_decl;
> +
> + tree t1 = TRAIT_EXPR_TYPE1 (expr);
> + tree t2 = TRAIT_EXPR_TYPE2 (expr);
> +
> + location_t decl_loc = location_of (t1);
> + if (decl_loc == input_location)
> + decl_loc = loc;
If we instead did
if (decl_loc != input_location)
loc = decl_loc;
could we always pass loc to inform instead of sometimes loc, sometimes
decl_loc?
> +
> + switch (TRAIT_EXPR_KIND (expr))
> + {
> + case CPTK_HAS_NOTHROW_ASSIGN:
> + inform (decl_loc, "%qT is not nothrow copy assignable", t1);
> + break;
> + case CPTK_HAS_NOTHROW_CONSTRUCTOR:
> + inform (decl_loc, "%qT is not nothrow default constructible", t1);
> + break;
> + case CPTK_HAS_NOTHROW_COPY:
> + inform (decl_loc, "%qT is not nothrow copy constructible", t1);
> + break;
> + case CPTK_HAS_TRIVIAL_ASSIGN:
> + inform (decl_loc, "%qT is not trivially copy assignable", t1);
> + break;
> + case CPTK_HAS_TRIVIAL_CONSTRUCTOR:
> + inform (decl_loc, "%qT is not trivially default constructible", t1);
> + break;
> + case CPTK_HAS_TRIVIAL_COPY:
> + inform (decl_loc, "%qT is not trivially copy constructible", t1);
> + break;
> + case CPTK_HAS_TRIVIAL_DESTRUCTOR:
> + inform (decl_loc, "%qT is not trivially destructible", t1);
> + break;
> + case CPTK_HAS_UNIQUE_OBJ_REPRESENTATIONS:
> + inform (decl_loc, "%qT does not have unique object representations",
> t1);
> + break;
> + case CPTK_HAS_VIRTUAL_DESTRUCTOR:
> + {
> + location_t dtor_loc = decl_loc;
> + if (NON_UNION_CLASS_TYPE_P (t1))
> + if (tree dtor = CLASSTYPE_DESTRUCTOR (t1))
> + dtor_loc = DECL_SOURCE_LOCATION (dtor);
> + inform (dtor_loc, "%qT does not have a virtual destructor", t1);
> + }
> + break;
> + case CPTK_IS_ABSTRACT:
> + inform (decl_loc, "%qT is not an abstract class", t1);
> + break;
> + case CPTK_IS_AGGREGATE:
> + inform (decl_loc, "%qT is not an aggregate", t1);
> + break;
> + case CPTK_IS_ARRAY:
> + inform (loc, "%qT is not an array", t1);
> + break;
> + case CPTK_IS_ASSIGNABLE:
> + inform (loc, "%qT is not assignable from %qT, because", t1, t2);
> + is_xible (MODIFY_EXPR, t1, t2, /*explain=*/true);
> + break;
> + case CPTK_IS_BASE_OF:
> + inform (decl_loc, "%qT is not a base of %qT", t1, t2);
> + break;
> + case CPTK_IS_BOUNDED_ARRAY:
> + inform (loc, "%qT is not a bounded array", t1);
> + break;
> + case CPTK_IS_CLASS:
> + inform (decl_loc, "%qT is not a class", t1);
> + break;
> + case CPTK_IS_CONST:
> + inform (loc, "%qT is not a const type", t1);
> + break;
> + case CPTK_IS_CONSTRUCTIBLE:
> + if (!TREE_VEC_LENGTH (t2))
> + inform (loc, "%qT is not default constructible, because", t1);
> + else
> + inform (loc, "%qT is not constructible from %qT, because", t1, t2);
> + is_xible (INIT_EXPR, t1, t2, /*explain=*/true);
> + break;
> + case CPTK_IS_CONVERTIBLE:
> + /* The errors produced here all seem to mention "convertible" in the
> + diagnostic, so an extra inform here appears redundant. */
> + is_convertible (t1, t2, /*explain=*/true);
> + break;
> + case CPTK_IS_DESTRUCTIBLE:
> + inform (loc, "%qT is not destructible, because", t1);
> + is_xible (BIT_NOT_EXPR, t1, NULL_TREE, /*explain=*/true);
> + break;
> + case CPTK_IS_EMPTY:
> + inform (decl_loc, "%qT is not an empty class", t1);
> + break;
> + case CPTK_IS_ENUM:
> + inform (decl_loc, "%qT is not an enum", t1);
> + break;
> + case CPTK_IS_FINAL:
> + inform (decl_loc, "%qT is not a final class", t1);
> + break;
> + case CPTK_IS_FUNCTION:
> + inform (loc, "%qT is not a function", t1);
> + break;
> + case CPTK_IS_INVOCABLE:
> + {
> + if (!TREE_VEC_LENGTH (t2))
> + inform (loc, "%qT is not invocable, because", t1);
> + else
> + inform (loc, "%qT is not invocable by %qT, because", t1, t2);
> + tree call = build_invoke (t1, t2, tf_error);
> + gcc_assert (call == error_mark_node);
> + }
> + break;
> + case CPTK_IS_LAYOUT_COMPATIBLE:
> + inform (loc, "%qT is not layout compatible with %qT", t1, t2);
> + break;
> + case CPTK_IS_LITERAL_TYPE:
> + inform (decl_loc, "%qT is not a literal type", t1);
> + break;
> + case CPTK_IS_MEMBER_FUNCTION_POINTER:
> + inform (loc, "%qT is not a member function pointer", t1);
> + break;
> + case CPTK_IS_MEMBER_OBJECT_POINTER:
> + inform (loc, "%qT is not a member object pointer", t1);
> + break;
> + case CPTK_IS_MEMBER_POINTER:
> + inform (loc, "%qT is not a member pointer", t1);
> + break;
> + case CPTK_IS_NOTHROW_ASSIGNABLE:
> + inform (loc, "%qT is not nothrow assignable from %qT, because", t1,
> t2);
> + is_nothrow_xible (MODIFY_EXPR, t1, t2, /*explain=*/true);
> + break;
> + case CPTK_IS_NOTHROW_CONSTRUCTIBLE:
> + if (!TREE_VEC_LENGTH (t2))
> + inform (loc, "%qT is not nothrow default constructible, because", t1);
> + else
> + inform (loc, "%qT is not nothrow constructible from %qT, because",
> + t1, t2);
> + is_nothrow_xible (INIT_EXPR, t1, t2, /*explain=*/true);
> + break;
> + case CPTK_IS_NOTHROW_CONVERTIBLE:
> + inform (loc, "%qT is not nothrow convertible from %qT, because", t1,
> t2);
> + is_nothrow_convertible (t1, t2, /*explain=*/true);
> + break;
> + case CPTK_IS_NOTHROW_DESTRUCTIBLE:
> + inform (loc, "%qT is not nothrow destructible, because", t1);
> + is_nothrow_xible (BIT_NOT_EXPR, t1, NULL_TREE, /*explain=*/true);
> + break;
> + case CPTK_IS_NOTHROW_INVOCABLE:
> + {
> + if (!TREE_VEC_LENGTH (t2))
> + inform (loc, "%qT is not nothrow invocable, because", t1);
> + else
> + inform (loc, "%qT is not nothrow invocable by %qT, because", t1, t2);
> + tree call = build_invoke (t1, t2, tf_error);
> + if (call != error_mark_node)
> + explain_not_noexcept (call);
> + }
> + break;
> + case CPTK_IS_OBJECT:
> + inform (loc, "%qT is not an object type", t1);
> + break;
> + case CPTK_IS_POINTER_INTERCONVERTIBLE_BASE_OF:
> + inform (decl_loc, "%qT is not a pointer-interconvertible base of %qT",
> + t1, t2);
> + break;
> + case CPTK_IS_POD:
> + inform (loc, "%qT is not a POD type", t1);
> + break;
> + case CPTK_IS_POINTER:
> + inform (loc, "%qT is not a pointer", t1);
> + break;
> + case CPTK_IS_POLYMORPHIC:
> + inform (decl_loc, "%qT is not a polymorphic type", t1);
> + break;
> + case CPTK_IS_REFERENCE:
> + inform (loc, "%qT is not a reference", t1);
> + break;
> + case CPTK_IS_SAME:
> + inform (loc, "%q#T is not the same as %q#T", t1, t2);
> + break;
> + case CPTK_IS_SCOPED_ENUM:
> + inform (decl_loc, "%qT is not a scoped enum", t1);
> + break;
> + case CPTK_IS_STD_LAYOUT:
> + inform (decl_loc, "%qT is not a standard layout type", t1);
> + break;
> + case CPTK_IS_TRIVIAL:
> + inform (decl_loc, "%qT is not a trivial type", t1);
> + break;
> + case CPTK_IS_TRIVIALLY_ASSIGNABLE:
> + inform (loc, "%qT is not trivially assignable from %qT, because", t1,
> t2);
> + is_trivially_xible (MODIFY_EXPR, t1, t2, /*explain=*/true);
> + break;
> + case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE:
> + if (!TREE_VEC_LENGTH (t2))
> + inform (loc, "%qT is not trivially default constructible, because", t1);
> + else
> + inform (loc, "%qT is not trivially constructible from %qT, because",
> + t1, t2);
> + is_trivially_xible (INIT_EXPR, t1, t2, /*explain=*/true);
> + break;
> + case CPTK_IS_TRIVIALLY_COPYABLE:
> + inform (decl_loc, "%qT is not trivially copyable", t1);
> + break;
> + case CPTK_IS_TRIVIALLY_DESTRUCTIBLE:
> + inform (loc, "%qT is not trivially destructible, because", t1);
> + is_trivially_xible (BIT_NOT_EXPR, t1, NULL_TREE, /*explain=*/true);
> + break;
> + case CPTK_IS_UNBOUNDED_ARRAY:
> + inform (loc, "%qT is not an unbounded array", t1);
> + break;
> + case CPTK_IS_UNION:
> + inform (decl_loc, "%qT is not a union", t1);
> + break;
> + case CPTK_IS_VIRTUAL_BASE_OF:
> + inform (decl_loc, "%qT is not a virtual base of %qT", t1, t2);
> + if (CLASS_TYPE_P (t2))
> + inform (location_of (t2), "%qT declared here", t2);
> + break;
> + case CPTK_IS_VOLATILE:
> + inform (loc, "%qT is not a volatile type", t1);
> + break;
> + case CPTK_RANK:
> + inform (loc, "%qT cannot yield a rank", t1);
> + break;
> + case CPTK_REF_CONSTRUCTS_FROM_TEMPORARY:
> + inform (loc, "%qT is not a reference that binds to a temporary "
> + "object of type %qT (direct-initialization)", t1, t2);
> + break;
> + case CPTK_REF_CONVERTS_FROM_TEMPORARY:
> + inform (loc, "%qT is not a reference that binds to a temporary "
> + "object of type %qT (copy-initialization)", t1, t2);
> + break;
> + case CPTK_IS_DEDUCIBLE:
> + inform (loc, "%qD is not deducible from %qT", t1, t2);
> + break;
> +#define DEFTRAIT_TYPE(CODE, NAME, ARITY) \
> + case CPTK_##CODE:
> +#include "cp-trait.def"
> +#undef DEFTRAIT_TYPE
> + /* Type-yielding traits aren't expressions. */
> + gcc_unreachable ();
> + /* We deliberately omit the default case so that when adding a new
> + trait we'll get reminded (by way of a warning) to handle it here. */
> + }
> +}
> +
> +/* Attempt to detect if this is a standard type trait, defined in terms
> + of a compiler builtin (above). If so, this will allow us to provide
> + more helpful diagnostics. */
> +
> +bool
> +maybe_diagnose_standard_trait (location_t loc, tree expr, tree args)
> +{
> + /* TODO: in some cases it would be possible to provide more helpful
> + diagnostics for negations of traits, e.g. '!is_same_v<T1, T2>'. */
> +
> + if (TREE_CODE (expr) == TEMPLATE_ID_EXPR || TREE_CODE (expr) == SCOPE_REF)
> + {
> + processing_template_decl_sentinel ptds;
> + expr = tsubst_expr (expr, args, tf_none, NULL_TREE);
> + expr = tree_strip_nop_conversions (expr);
> + args = NULL_TREE;
> + }
Perhaps the callers should be responsible for performing this
substitution, rather than doing it here? That way
maybe_diagnose_standard_trait can assume expr is non-dependent and it
can only be responsible for diagnosing. IIUC only diagnose_atomic_constraint
needs to do this substitution, and not diagnose_failing_condition.
Besides these small comments, LGTM!
> +
> + if (VAR_P (expr) && DECL_LANG_SPECIFIC (expr) && DECL_USE_TEMPLATE (expr))
> + {
> + gcc_assert (!args);
> +
> + tree tinfo = DECL_TEMPLATE_INFO (expr);
> + if (PRIMARY_TEMPLATE_P (TI_TEMPLATE (tinfo)) && TI_PARTIAL_INFO
> (tinfo))
> + tinfo = TI_PARTIAL_INFO (tinfo);
> + else if (DECL_TEMPLATE_SPECIALIZATION (expr))
> + /* In an explicit specialisation we no longer know what the original
> + initializer looked like. */
> + tinfo = NULL_TREE;
> +
> + if (tinfo)
> + {
> + expr = DECL_INITIAL (DECL_TEMPLATE_RESULT (TI_TEMPLATE (tinfo)));
> + args = TI_ARGS (tinfo);
> + }
> + }
> +
> + if (TREE_CODE (expr) == TRAIT_EXPR)
> + {
> + diagnose_trait_expr (loc, expr, args);
> + return true;
> + }
> +
> + return false;
> +}
> +
> /* Returns true if TYPE meets the requirements for the specified KIND,
> false otherwise.
>
> diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
> index af2cbaff8fd..a077312673e 100644
> --- a/gcc/cp/typeck.cc
> +++ b/gcc/cp/typeck.cc
> @@ -4475,7 +4475,11 @@ cp_build_function_call_vec (tree function, vec<tree,
> va_gc> **params,
> {
> if (complain & tf_error)
> {
> - if (!flag_diagnostics_show_caret)
> + if (is_stub_object (original))
> + error_at (input_location,
> + "%qT cannot be used as a function",
> + TREE_TYPE (original));
> + else if (!flag_diagnostics_show_caret)
> error_at (input_location,
> "%qE cannot be used as a function", original);
> else if (DECL_P (original))
> @@ -4617,12 +4621,8 @@ convert_arguments (tree typelist, vec<tree, va_gc>
> **values, tree fndecl,
> if (type == void_type_node)
> {
> if (complain & tf_error)
> - {
> - error_args_num (input_location, fndecl, /*too_many_p=*/true);
> - return i;
> - }
> - else
> - return -1;
> + error_args_num (input_location, fndecl, /*too_many_p=*/true);
> + return -1;
> }
>
> /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue.
> diff --git a/gcc/cp/typeck2.cc b/gcc/cp/typeck2.cc
> index 45edd180173..97852d3c727 100644
> --- a/gcc/cp/typeck2.cc
> +++ b/gcc/cp/typeck2.cc
> @@ -119,6 +119,11 @@ cxx_readonly_error (location_t loc, tree arg, enum
> lvalue_use errstring)
> G_("increment of read-only reference %qD"),
> G_("decrement of read-only reference %qD"),
> TREE_OPERAND (arg, 0));
> + else if (is_stub_object (arg))
> + {
> + gcc_assert (errstring == lv_assign);
> + error_at (loc, "assignment to read-only type %qT", TREE_TYPE (arg));
> + }
> else
> readonly_error (loc, arg, errstring);
> }
> diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-traits3.C
> b/gcc/testsuite/g++.dg/cpp2a/concepts-traits3.C
> index 3e87da4611e..90d859a6c69 100644
> --- a/gcc/testsuite/g++.dg/cpp2a/concepts-traits3.C
> +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-traits3.C
> @@ -1,49 +1,58 @@
> // PR c++/100474
> // { dg-do compile { target c++20 } }
>
> -struct S { S() = delete; S(const S&); };
> +struct S { S() = delete; S(const S&); }; // { dg-line S }
>
> template<class T>
> concept Aggregate = __is_aggregate(T);
> -// { dg-message "'S' is not an aggregate" "" { target *-*-* } .-1 }
> +// { dg-message "'S' is not an aggregate" "" { target *-*-* } S }
>
> template<class T>
> concept TriviallyCopyable = __is_trivially_copyable(T);
> -// { dg-message "'S' is not trivially copyable" "" { target *-*-* } .-1 }
> +// { dg-message "'S' is not trivially copyable" "" { target *-*-* } S }
>
> template<class T, class U>
> concept Assignable = __is_assignable(T, U);
> -// { dg-message "'S' is not assignable from 'int'" "" { target *-*-* } .-1 }
> +// { dg-message "'S' is not assignable from 'int', because" "" { target
> *-*-* } .-1 }
> +// { dg-error "no match for 'operator='" "" { target *-*-* } .-2 }
>
> template<class T, class U>
> concept TriviallyAssignable = __is_trivially_assignable(T, U);
> // { dg-message "'S' is not trivially assignable from 'int'" "" { target
> *-*-* } .-1 }
> +// { dg-error "no match for 'operator='" "" { target *-*-* } .-2 }
>
> template<class T, class U>
> concept NothrowAssignable = __is_nothrow_assignable(T, U);
> // { dg-message "'S' is not nothrow assignable from 'int'" "" { target *-*-*
> } .-1 }
> +// { dg-error "no match for 'operator='" "" { target *-*-* } .-2 }
>
> template<class T, class... Args>
> concept Constructible = __is_constructible(T, Args...);
> // { dg-message "'S' is not default constructible" "" { target *-*-* } .-1 }
> -// { dg-message "'S' is not constructible from 'int'" "" { target *-*-* }
> .-2 }
> -// { dg-message "'S' is not constructible from 'int, char'" "" { target
> *-*-* } .-3 }
> +// { dg-error "use of deleted function 'S::S\\(\\)'" "" { target *-*-* } .-2
> }
> +// { dg-message "'S' is not constructible from 'int'" "" { target *-*-* }
> .-3 }
> +// { dg-message "'S' is not constructible from 'int, char'" "" { target
> *-*-* } .-4 }
> +// { dg-error "no matching function for call to 'S::S" "" { target *-*-* }
> .-5 }
>
> template<class T, class... Args>
> concept TriviallyConstructible = __is_trivially_constructible(T, Args...);
> // { dg-message "'S' is not trivially default constructible" "" { target
> *-*-* } .-1 }
> -// { dg-message "'S' is not trivially constructible from 'int'" "" { target
> *-*-* } .-2 }
> -// { dg-message "'S' is not trivially constructible from 'int, char'" "" {
> target *-*-* } .-3 }
> +// { dg-error "use of deleted function 'S::S\\(\\)'" "" { target *-*-* } .-2
> }
> +// { dg-message "'S' is not trivially constructible from 'int'" "" { target
> *-*-* } .-3 }
> +// { dg-message "'S' is not trivially constructible from 'int, char'" "" {
> target *-*-* } .-4 }
> +// { dg-error "no matching function for call to 'S::S" "" { target *-*-* }
> .-5 }
>
> template<class T, class... Args>
> concept NothrowConstructible = __is_nothrow_constructible(T, Args...);
> // { dg-message "'S' is not nothrow default constructible" "" { target *-*-*
> } .-1 }
> -// { dg-message "'S' is not nothrow constructible from 'int'" "" { target
> *-*-* } .-2 }
> -// { dg-message "'S' is not nothrow constructible from 'int, char'" "" {
> target *-*-* } .-3 }
> +// { dg-error "use of deleted function 'S::S\\(\\)'" "" { target *-*-* } .-2
> }
> +// { dg-message "'S' is not nothrow constructible from 'int'" "" { target
> *-*-* } .-3 }
> +// { dg-message "'S' is not nothrow constructible from 'int, char'" "" {
> target *-*-* } .-4 }
> +// { dg-error "no matching function for call to 'S::S" "" { target *-*-* }
> .-5 }
>
> template<class T>
> concept UniqueObjReps = __has_unique_object_representations(T);
> -// { dg-message "'S' does not have unique object representations" "" {
> target *-*-* } .-1 }
> +// { dg-message "'S' does not have unique object representations" "" {
> target *-*-* } S }
>
> static_assert(Aggregate<S>); // { dg-error "assert" }
> static_assert(TriviallyCopyable<S>); // { dg-error "assert" }
> diff --git a/gcc/testsuite/g++.dg/cpp2a/concepts-traits4.C
> b/gcc/testsuite/g++.dg/cpp2a/concepts-traits4.C
> new file mode 100644
> index 00000000000..caad816bf3d
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/cpp2a/concepts-traits4.C
> @@ -0,0 +1,77 @@
> +// PR c++/117294
> +// { dg-do compile { target c++20 } }
> +// { dg-additional-options "-fconcepts-diagnostics-depth=2" }
> +
> +template <typename T> struct norm
> + { static constexpr bool value = __is_constructible(T); };
> +template <typename T> constexpr bool norm_v = __is_constructible(T);
> +
> +template <typename T> struct part
> + { static constexpr bool value = __is_constructible(T); };
> +template <typename T> struct part<T*>
> + { static constexpr bool value = false; };
> +template <typename T> struct part<const T>
> + { static constexpr bool value = __is_same(T, void); };
> +template <typename T> constexpr bool part_v = __is_constructible(T);
> +template <typename T> constexpr bool part_v<T*> = false;
> +template <typename T> constexpr bool part_v<const T> = __is_same(T, void);
> +
> +template <typename T> struct expl
> + { static constexpr bool value = __is_constructible(T); };
> +template <> struct expl<int*>
> + { static constexpr bool value = false; };
> +template <> struct expl<const int>
> + { static constexpr bool value = __is_same(int, void); };
> +template <typename T> constexpr bool expl_v = __is_constructible(T);
> +template <> constexpr bool expl_v<int*> = false;
> +template <> constexpr bool expl_v<const int> = __is_same(int, void);
> +
> +template <typename T> concept test_norm = norm<T>::value; // { dg-line norm
> }
> +template <typename T> concept test_part = part<T>::value; // { dg-line part
> }
> +template <typename T> concept test_expl = expl<T>::value; // { dg-line expl
> }
> +template <typename T> concept test_norm_v = norm_v<T>; // { dg-line norm_v }
> +template <typename T> concept test_part_v = part_v<T>; // { dg-line part_v }
> +template <typename T> concept test_expl_v = expl_v<T>; // { dg-line expl_v }
> +
> +static_assert(test_norm<void>); // { dg-error "assert" }
> +static_assert(test_part<void>); // { dg-error "assert" }
> +static_assert(test_expl<void>); // { dg-error "assert" }
> +static_assert(test_norm_v<void>); // { dg-error "assert" }
> +static_assert(test_part_v<void>); // { dg-error "assert" }
> +static_assert(test_expl_v<void>); // { dg-error "assert" }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> norm }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> part }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> expl }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> norm_v }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> part_v }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> expl_v }
> +// { dg-prune-output "'void' is incomplete" }
> +
> +static_assert(test_part<int*>); // { dg-error "assert" }
> +static_assert(test_expl<int*>); // { dg-error "assert" }
> +static_assert(test_part_v<int*>); // { dg-error "assert" }
> +static_assert(test_expl_v<int*>); // { dg-error "assert" }
> +// { dg-message ".with T = int\\*.. evaluated to .false." "" { target *-*-*
> } part }
> +// { dg-message ".with T = int\\*.. evaluated to .false." "" { target *-*-*
> } expl }
> +// { dg-message ".with T = int\\*.. evaluated to .false." "" { target *-*-*
> } part_v }
> +// { dg-message ".with T = int\\*.. evaluated to .false." "" { target *-*-*
> } expl_v }
> +
> +static_assert(test_part<const int>); // { dg-error "assert" }
> +static_assert(test_part_v<const int>); // { dg-error "assert" }
> +// { dg-message "'int' is not the same as 'void'" "" { target *-*-* } part }
> +// { dg-message "'int' is not the same as 'void'" "" { target *-*-* } part_v
> }
> +
> +struct S { S(int); };
> +static_assert(requires { requires test_norm<S>; }); // { dg-error "assert" }
> +static_assert(requires { requires test_part<S>; }); // { dg-error "assert" }
> +static_assert(requires { requires test_expl<S>; }); // { dg-error "assert" }
> +static_assert(requires { requires test_norm_v<S>; }); // { dg-error
> "assert" }
> +static_assert(requires { requires test_part_v<S>; }); // { dg-error
> "assert" }
> +static_assert(requires { requires test_expl_v<S>; }); // { dg-error
> "assert" }
> +// { dg-message "'S' is not default constructible" "" { target *-*-* } norm }
> +// { dg-message "'S' is not default constructible" "" { target *-*-* } part }
> +// { dg-message "'S' is not default constructible" "" { target *-*-* } expl }
> +// { dg-message "'S' is not default constructible" "" { target *-*-* }
> norm_v }
> +// { dg-message "'S' is not default constructible" "" { target *-*-* }
> part_v }
> +// { dg-message "'S' is not default constructible" "" { target *-*-* }
> expl_v }
> +// { dg-prune-output "no matching function for call" }
> diff --git a/gcc/testsuite/g++.dg/diagnostic/static_assert5.C
> b/gcc/testsuite/g++.dg/diagnostic/static_assert5.C
> new file mode 100644
> index 00000000000..16681b25e38
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/diagnostic/static_assert5.C
> @@ -0,0 +1,70 @@
> +// PR c++/117294
> +// { dg-do compile { target c++14 } }
> +
> +template <typename T> struct norm
> + { static constexpr bool value = __is_constructible(T); };
> +template <typename T> constexpr bool norm_v = __is_constructible(T);
> +
> +template <typename T> struct part
> + { static constexpr bool value = __is_constructible(T); };
> +template <typename T> struct part<T*>
> + { static constexpr bool value = false; };
> +template <typename T> struct part<const T>
> + { static constexpr bool value = __is_same(T, void); };
> +template <typename T> constexpr bool part_v = __is_constructible(T);
> +template <typename T> constexpr bool part_v<T*> = false;
> +template <typename T> constexpr bool part_v<const T> = __is_same(T, void);
> +
> +template <typename T> struct expl
> + { static constexpr bool value = __is_constructible(T); };
> +template <> struct expl<int*>
> + { static constexpr bool value = false; };
> +template <> struct expl<const int>
> + { static constexpr bool value = __is_same(int, void); };
> +template <typename T> constexpr bool expl_v = __is_constructible(T);
> +template <> constexpr bool expl_v<int*> = false;
> +template <> constexpr bool expl_v<const int> = __is_same(int, void);
> +
> +// === Primary template can give customised diagnostics when using traits
> +static_assert(norm<void>::value); // { dg-error "assert" }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> .-1 }
> +static_assert(part<void>::value); // { dg-error "assert" }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> .-1 }
> +static_assert(expl<void>::value); // { dg-error "assert" }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> .-1 }
> +static_assert(norm_v<void>); // { dg-error "assert" }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> .-1 }
> +static_assert(part_v<void>); // { dg-error "assert" }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> .-1 }
> +static_assert(expl_v<void>); // { dg-error "assert" }
> +// { dg-message "'void' is not default constructible" "" { target *-*-* }
> .-1 }
> +
> +// { dg-prune-output "'void' is incomplete" }
> +
> +
> +// === Specialisations don't customise just because primary template had
> trait
> +static_assert(part<int*>::value); // { dg-error "assert" }
> +// { dg-bogus "default constructible" "" { target *-*-* } .-1 }
> +static_assert(expl<int*>::value); // { dg-error "assert" }
> +// { dg-bogus "default constructible" "" { target *-*-* } .-1 }
> +static_assert(part_v<int*>); // { dg-error "assert" }
> +// { dg-bogus "default constructible" "" { target *-*-* } .-1 }
> +static_assert(expl_v<int*>); // { dg-error "assert" }
> +// { dg-bogus "default constructible" "" { target *-*-* } .-1 }
> +
> +
> +// === But partial specialisations actually using a trait can customise
> +static_assert(part<const int>::value); // { dg-error "assert" }
> +// { dg-message "'int' is not the same as 'void'" "" { target *-*-* } .-1 }
> +static_assert(part_v<const int>); // { dg-error "assert" }
> +// { dg-message "'int' is not the same as 'void'" "" { target *-*-* } .-1 }
> +
> +
> +// === For these cases, we no longer know that the error was caused by the
> trait
> +// === because it's been folded away before we process the failure.
> +static_assert(expl<const int>::value); // { dg-error "assert" }
> +// { dg-bogus "because" "" { target *-*-* } .-1 }
> +static_assert(expl_v<const int>); // { dg-error "assert" }
> +// { dg-bogus "because" "" { target *-*-* } .-1 }
> +static_assert(__is_constructible(void)); // { dg-error "assert" }
> +// { dg-bogus "because" "" { target *-*-* } .-1 }
> diff --git a/gcc/testsuite/g++.dg/ext/has_virtual_destructor2.C
> b/gcc/testsuite/g++.dg/ext/has_virtual_destructor2.C
> new file mode 100644
> index 00000000000..14eea8095d3
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/ext/has_virtual_destructor2.C
> @@ -0,0 +1,27 @@
> +// { dg-do compile { target c++11 } }
> +
> +template <typename T> struct has_virtual_destructor {
> + static constexpr bool value = __has_virtual_destructor(T);
> +};
> +
> +static_assert(has_virtual_destructor<int>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'int' does not have a virtual destructor" "" { target *-*-*
> } .-1 }
> +
> +struct A {}; // { dg-message "'A' does not have a virtual destructor" }
> +static_assert(has_virtual_destructor<A>::value, ""); // { dg-error "assert"
> }
> +
> +struct B {
> + ~B(); // { dg-message "'B' does not have a virtual destructor" }
> +};
> +static_assert(has_virtual_destructor<B>::value, ""); // { dg-error "assert"
> }
> +
> +struct C { // { dg-bogus "" }
> + virtual ~C(); // { dg-bogus "" }
> +};
> +static_assert(has_virtual_destructor<C[5]>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'C \\\[5\\\]' does not have a virtual destructor" "" {
> target *-*-* } .-1 }
> +
> +union U { // { dg-message "'U' does not have a virtual destructor" }
> + ~U();
> +};
> +static_assert(has_virtual_destructor<U>::value, ""); // { dg-error "assert"
> }
> diff --git a/gcc/testsuite/g++.dg/ext/is_assignable2.C
> b/gcc/testsuite/g++.dg/ext/is_assignable2.C
> new file mode 100644
> index 00000000000..b346d7b235d
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/ext/is_assignable2.C
> @@ -0,0 +1,36 @@
> +// { dg-do compile { target c++11 } }
> +
> +template <typename T>
> +struct is_copy_assignable {
> + static constexpr bool value = __is_assignable(T&, const T&);
> +};
> +
> +static_assert(is_copy_assignable<const int>::value, ""); // { dg-error
> "assert" }
> +// { dg-error "assignment to read-only type 'const int'" "" { target *-*-* }
> .-1 }
> +
> +struct A {
> + void operator=(A) = delete; // { dg-message "declared here" }
> +};
> +static_assert(is_copy_assignable<A>::value, ""); // { dg-error "assert" }
> +// { dg-message "is not assignable" "" { target *-*-* } .-1 }
> +// { dg-error "use of deleted function" "" { target *-*-* } .-2 }
> +
> +template <typename T>
> +struct is_nothrow_copy_assignable {
> + static constexpr bool value = __is_nothrow_assignable(T&, const T&);
> +};
> +struct B {
> + void operator=(const B&); // { dg-message "noexcept" }
> +};
> +static_assert(is_nothrow_copy_assignable<B>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "is not nothrow assignable" "" { target *-*-* } .-1 }
> +
> +template <typename T>
> +struct is_trivially_copy_assignable {
> + static constexpr bool value = __is_trivially_assignable(T&, const T&);
> +};
> +struct C {
> + void operator=(const C&); // { dg-message "non-trivial" }
> +};
> +static_assert(is_trivially_copy_assignable<C>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "is not trivially assignable" "" { target *-*-* } .-1 }
> diff --git a/gcc/testsuite/g++.dg/ext/is_constructible9.C
> b/gcc/testsuite/g++.dg/ext/is_constructible9.C
> new file mode 100644
> index 00000000000..5448878c122
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/ext/is_constructible9.C
> @@ -0,0 +1,60 @@
> +// { dg-do compile { target c++11 } }
> +
> +template <typename T, typename... Args>
> +struct is_constructible {
> + static constexpr bool value = __is_constructible(T, Args...);
> +};
> +
> +static_assert(is_constructible<void>::value, ""); // { dg-error "assert" }
> +// { dg-message "'void' is not default constructible, because" "" { target
> *-*-* } .-1 }
> +// { dg-error "'void' is incomplete" "" { target *-*-* } .-2 }
> +
> +static_assert(is_constructible<int&, const int&>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'int&' is not constructible from 'const int&', because" ""
> { target *-*-* } .-1 }
> +// { dg-error "discards qualifiers" "" { target *-*-* } .-2 }
> +
> +static_assert(is_constructible<int, int, int>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'int' is not constructible from 'int, int', because" "" {
> target *-*-* } .-1 }
> +// { dg-error "too many initializers for non-class type 'int'" "" { target
> *-*-* } .-2 }
> +
> +struct A {
> + A(int); // { dg-message "candidate" }
> +};
> +static_assert(is_constructible<A, int, int>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'A' is not constructible from 'int, int', because" "" {
> target *-*-* } .-1 }
> +// { dg-error "no matching function for call to" "" { target *-*-* } .-2 }
> +
> +template <typename T, typename... Args>
> +struct is_nothrow_constructible {
> + static constexpr bool value = __is_nothrow_constructible(T, Args...);
> +};
> +
> +struct B {
> + B(int); // { dg-message "candidate" }
> +};
> +static_assert(is_nothrow_constructible<B>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'B' is not nothrow default constructible, because" "" {
> target *-*-* } .-1 }
> +// { dg-error "no matching function for call to" "" { target *-*-* } .-2 }
> +
> +struct C {
> + C(int); // { dg-message "noexcept" }
> +};
> +static_assert(is_nothrow_constructible<C, int>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'C' is not nothrow constructible from 'int', because" "" {
> target *-*-* } .-1 }
> +
> +template <typename T, typename... Args>
> +struct is_trivially_constructible {
> + static constexpr bool value = __is_trivially_constructible(T, Args...);
> +};
> +
> +struct D {
> + D(); // { dg-message "non-trivial" }
> +};
> +static_assert(is_trivially_constructible<D>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'D' is not trivially default constructible, because" "" {
> target *-*-* } .-1 }
> +
> +struct E {
> + operator int(); // { dg-message "non-trivial" }
> +};
> +static_assert(is_trivially_constructible<int, E>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'int' is not trivially constructible from 'E', because" ""
> { target *-*-* } .-1 }
> diff --git a/gcc/testsuite/g++.dg/ext/is_convertible7.C
> b/gcc/testsuite/g++.dg/ext/is_convertible7.C
> new file mode 100644
> index 00000000000..b38fc042de9
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/ext/is_convertible7.C
> @@ -0,0 +1,29 @@
> +// { dg-do compile { target c++11 } }
> +
> +template <typename T, typename U>
> +struct is_convertible {
> + static constexpr bool value = __is_convertible(T, U);
> +};
> +
> +static_assert(is_convertible<int*, int>::value, ""); // { dg-error "assert"
> }
> +// { dg-error "invalid conversion" "" { target *-*-* } .-1 }
> +
> +static_assert(is_convertible<int(), double (*)()>::value, ""); // {
> dg-error "assert" }
> +// { dg-error "invalid conversion" "" { target *-*-* } .-1 }
> +
> +struct A {
> + explicit A(int);
> +};
> +static_assert(is_convertible<int, A>::value, ""); // { dg-error "assert" }
> +// { dg-error "could not convert 'int' to 'A'" "" { target *-*-* } .-1 }
> +
> +template <typename T, typename U>
> +struct is_nothrow_convertible {
> + static constexpr bool value = __is_nothrow_convertible(T, U);
> +};
> +
> +struct B {
> + B(int); // { dg-message "noexcept" }
> +};
> +static_assert(is_nothrow_convertible<int, B>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'int' is not nothrow convertible from 'B', because" "" {
> target *-*-* } .-1 }
> diff --git a/gcc/testsuite/g++.dg/ext/is_destructible2.C
> b/gcc/testsuite/g++.dg/ext/is_destructible2.C
> new file mode 100644
> index 00000000000..cb42c3c730c
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/ext/is_destructible2.C
> @@ -0,0 +1,48 @@
> +// { dg-do compile { target c++11 } }
> +
> +template <typename T>
> +struct is_destructible {
> + static constexpr bool value = __is_destructible(T);
> +};
> +
> +static_assert(is_destructible<void>::value, ""); // { dg-error "assert" }
> +// { dg-message "'void' is not destructible, because" "" { target *-*-* }
> .-1 }
> +// { dg-error "'void' is incomplete" "" { target *-*-* } .-2 }
> +
> +struct A {
> + ~A() = delete; // { dg-message "declared here" }
> +};
> +static_assert(is_destructible<A>::value, ""); // { dg-error "assert" }
> +// { dg-message "'A' is not destructible, because" "" { target *-*-* } .-1 }
> +// { dg-error "use of deleted function" "" { target *-*-* } .-2 }
> +
> +struct B {
> +private:
> + ~B(); // { dg-message "declared private here" }
> +};
> +static_assert(is_destructible<B>::value, ""); // { dg-error "assert" }
> +// { dg-message "'B' is not destructible, because" "" { target *-*-* } .-1 }
> +// { dg-error "private within this context" "" { target *-*-* } .-2 }
> +
> +template <typename T>
> +struct is_nothrow_destructible {
> + static constexpr bool value = __is_nothrow_destructible(T);
> +};
> +
> +struct C {
> + ~C() noexcept(false); // { dg-message "noexcept" }
> +};
> +static_assert(is_nothrow_destructible<C>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'C' is not nothrow destructible, because" "" { target *-*-*
> } .-1 }
> +
> +template <typename T>
> +struct is_trivially_destructible {
> + static constexpr bool value = __is_trivially_destructible(T);
> +};
> +
> +struct D {
> + ~D();
> +};
> +struct E { D d; }; // { dg-message "non-trivial" }
> +static_assert(is_trivially_destructible<E>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'E' is not trivially destructible, because" "" { target
> *-*-* } .-1 }
> diff --git a/gcc/testsuite/g++.dg/ext/is_invocable5.C
> b/gcc/testsuite/g++.dg/ext/is_invocable5.C
> new file mode 100644
> index 00000000000..4ef42487ba8
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/ext/is_invocable5.C
> @@ -0,0 +1,41 @@
> +// { dg-do compile { target c++11 } }
> +
> +template <typename F, typename... Args>
> +struct is_invocable {
> + static constexpr bool value = __is_invocable(F, Args...);
> +};
> +
> +static_assert(is_invocable<int>::value, ""); // { dg-error "assert" }
> +// { dg-message "'int' is not invocable, because" "" { target *-*-* } .-1 }
> +// { dg-error "'int' cannot be used as a function" "" { target *-*-* } .-2 }
> +
> +static_assert(is_invocable<void(*)(), int>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'void \[^'\]*' is not invocable by 'int', because" "" {
> target *-*-* } .-1 }
> +// { dg-error "too many arguments" "" { target *-*-* } .-2 }
> +
> +struct A {};
> +static_assert(is_invocable<const A&&, int, double>::value, ""); // {
> dg-error "assert" }
> +// { dg-message "'const A&&' is not invocable by 'int, double', because" ""
> { target *-*-* } .-1 }
> +// { dg-error "no match for call to " "" { target *-*-* } .-2 }
> +
> +struct B {
> + void operator()() = delete; // { dg-message "declared here" }
> +};
> +static_assert(is_invocable<B>::value, ""); // { dg-error "assert" }
> +// { dg-message "'B' is not invocable, because" "" { target *-*-* } .-1 }
> +// { dg-error "use of deleted function" "" { target *-*-* } .-2 }
> +
> +template <typename F, typename... Args>
> +struct is_nothrow_invocable {
> + static constexpr bool value = __is_nothrow_invocable(F, Args...);
> +};
> +
> +static_assert(is_nothrow_invocable<void(*)()>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'void \[^'\]*' is not nothrow invocable, because" "" {
> target *-*-* } .-1 }
> +// { dg-message "'void \[^'\]*' is not 'noexcept'" "" { target *-*-* } .-2 }
> +
> +struct C {
> + int operator()(int, double) const; // { dg-message "noexcept" }
> +};
> +static_assert(is_nothrow_invocable<const C&, int, int>::value, ""); // {
> dg-error "assert" }
> +// { dg-message "'const C&' is not nothrow invocable by 'int, int', because"
> "" { target *-*-* } .-1 }
> diff --git a/gcc/testsuite/g++.dg/ext/is_virtual_base_of_diagnostic2.C
> b/gcc/testsuite/g++.dg/ext/is_virtual_base_of_diagnostic2.C
> new file mode 100644
> index 00000000000..ac28121d49f
> --- /dev/null
> +++ b/gcc/testsuite/g++.dg/ext/is_virtual_base_of_diagnostic2.C
> @@ -0,0 +1,13 @@
> +// { dg-do compile { target c++11 } }
> +
> +template <typename T, typename U>
> +struct is_virtual_base_of {
> + static constexpr bool value = __builtin_is_virtual_base_of(T, U);
> +};
> +
> +static_assert(is_virtual_base_of<int, int>::value, ""); // { dg-error
> "assert" }
> +// { dg-message "'int' is not a virtual base of 'int'" "" { target *-*-* }
> .-1 }
> +
> +struct A {}; // { dg-message "'A' is not a virtual base of 'B'" }
> +struct B : A {}; // { dg-message "declared here" }
> +static_assert(is_virtual_base_of<A, B>::value, ""); // { dg-error "assert" }
> diff --git a/libstdc++-v3/testsuite/20_util/any/misc/any_cast_neg.cc
> b/libstdc++-v3/testsuite/20_util/any/misc/any_cast_neg.cc
> index 9740e09ac5e..9e5c64cf3f6 100644
> --- a/libstdc++-v3/testsuite/20_util/any/misc/any_cast_neg.cc
> +++ b/libstdc++-v3/testsuite/20_util/any/misc/any_cast_neg.cc
> @@ -27,6 +27,7 @@ void test01()
> const any y(1);
> any_cast<int&>(y); // { dg-error "here" }
> // { dg-error "Template argument must be constructible from a const value"
> "" { target { *-*-* } } 0 }
> + // { dg-error "binding reference of type 'int&' to 'const int' discards
> qualifiers" "" { target { *-*-* } } 0 }
> }
>
> void test02()
> @@ -34,6 +35,7 @@ void test02()
> any y(1);
> any_cast<int&&>(y); // { dg-error "here" }
> // { dg-error "Template argument must be constructible from an lvalue" ""
> { target { *-*-* } } 0 }
> + // { dg-error "cannot bind rvalue reference of type 'int&&' to lvalue of
> type 'int'" "" { target { *-*-* } } 0 }
> }
>
> void test03()
> @@ -41,6 +43,7 @@ void test03()
> any y(1);
> any_cast<int&>(std::move(y)); // { dg-error "here" }
> // { dg-error "Template argument must be constructible from an rvalue" ""
> { target { *-*-* } } 0 }
> + // { dg-error "cannot bind non-const lvalue reference of type 'int&' to an
> rvalue of type 'int'" "" { target { *-*-* } } 0 }
> }
>
> // { dg-prune-output "invalid 'static_cast'" }
> diff --git a/libstdc++-v3/testsuite/20_util/expected/illformed_neg.cc
> b/libstdc++-v3/testsuite/20_util/expected/illformed_neg.cc
> index 69c13b48a22..69aa4a17960 100644
> --- a/libstdc++-v3/testsuite/20_util/expected/illformed_neg.cc
> +++ b/libstdc++-v3/testsuite/20_util/expected/illformed_neg.cc
> @@ -13,6 +13,7 @@ test_unexpected()
> std::unexpected<void()> func(test_unexpected); // { dg-error "here" }
> // { dg-error "no matching function for call to" "" { target *-*-* } 0 }
> // { dg-error "invalidly declared function type" "" { target *-*-* } 0 }
> + // { dg-error "could not convert" "" { target *-*-* } 0 }
>
> // an array type,
> std::unexpected<int[2]> array(i); // { dg-error "here" }
> diff --git a/libstdc++-v3/testsuite/20_util/optional/monadic/or_else_neg.cc
> b/libstdc++-v3/testsuite/20_util/optional/monadic/or_else_neg.cc
> index f5028c15bc3..12a67bbc118 100644
> --- a/libstdc++-v3/testsuite/20_util/optional/monadic/or_else_neg.cc
> +++ b/libstdc++-v3/testsuite/20_util/optional/monadic/or_else_neg.cc
> @@ -26,4 +26,5 @@ test02()
>
> std::optional<move_only> mo;
> mo.or_else([]{ return std::optional<move_only>{}; }); // { dg-error "no
> matching function" }
> + // { dg-error "use of deleted function" "" { target *-*-* } 0 }
> }
> diff --git a/libstdc++-v3/testsuite/23_containers/array/creation/3_neg.cc
> b/libstdc++-v3/testsuite/23_containers/array/creation/3_neg.cc
> index ae06302b952..133522809b1 100644
> --- a/libstdc++-v3/testsuite/23_containers/array/creation/3_neg.cc
> +++ b/libstdc++-v3/testsuite/23_containers/array/creation/3_neg.cc
> @@ -54,3 +54,5 @@ test03()
> }
>
> // { dg-prune-output "static assertion failed" }
> +// { dg-prune-output "use of deleted function" }
> +// { dg-prune-output "could not convert" }
> diff --git a/libstdc++-v3/testsuite/24_iterators/range_generators/lwg3900.cc
> b/libstdc++-v3/testsuite/24_iterators/range_generators/lwg3900.cc
> index 957879e8862..08fd5c2ab1d 100644
> --- a/libstdc++-v3/testsuite/24_iterators/range_generators/lwg3900.cc
> +++ b/libstdc++-v3/testsuite/24_iterators/range_generators/lwg3900.cc
> @@ -13,4 +13,5 @@ bar(std::allocator_arg_t, std::pmr::memory_resource& mr) //
> { dg-error "here" }
> }
>
> // { dg-error "static assertion failed" "" { target *-*-* } 0 }
> -// { dg-error "no matching function .*memory_resource&" "" { target *-*-* }
> 0 }
> +// { dg-error "could not convert 'const std::pmr::memory_resource'" "" {
> target *-*-* } 0 }
> +// { dg-error "no matching function \[^\n\r\]*memory_resource&" "" { target
> *-*-* } 0 }
> diff --git
> a/libstdc++-v3/testsuite/29_atomics/atomic/requirements/types_neg.cc
> b/libstdc++-v3/testsuite/29_atomics/atomic/requirements/types_neg.cc
> index 5aa32433c7a..cfe44d255ca 100644
> --- a/libstdc++-v3/testsuite/29_atomics/atomic/requirements/types_neg.cc
> +++ b/libstdc++-v3/testsuite/29_atomics/atomic/requirements/types_neg.cc
> @@ -20,6 +20,7 @@
> #include <atomic>
>
> std::atomic<const int> a; // { dg-error "here" }
> +// { dg-error "assignment to read-only type" "" { target *-*-* } 0 }
>
> struct MoveOnly
> {
> @@ -40,3 +41,4 @@ struct NoMove
> std::atomic<NoMove> c; // { dg-error "here" }
>
> // { dg-error "static assertion failed" "" { target *-*-* } 0 }
> +// { dg-error "use of deleted function" "" { target *-*-* } 0 }
> diff --git
> a/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/invocable_neg.cc
> b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/invocable_neg.cc
> index 93b31863650..2b2fce42d2f 100644
> ---
> a/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/invocable_neg.cc
> +++
> b/libstdc++-v3/testsuite/30_threads/stop_token/stop_callback/invocable_neg.cc
> @@ -32,3 +32,4 @@ test01(std::stop_token& tok, F& f)
> }
>
> // { dg-error "static assertion failed" "" { target *-*-* } 0 }
> +// { dg-error "no match for call" "" { target *-*-* } 0 }
> diff --git a/libstdc++-v3/testsuite/std/format/arguments/args_neg.cc
> b/libstdc++-v3/testsuite/std/format/arguments/args_neg.cc
> index ded56fe63ab..83c7b22d081 100644
> --- a/libstdc++-v3/testsuite/std/format/arguments/args_neg.cc
> +++ b/libstdc++-v3/testsuite/std/format/arguments/args_neg.cc
> @@ -42,3 +42,4 @@ void test_const_arg()
> }
>
> // { dg-prune-output "no matching function for call to
> .*::basic_format_arg<" }
> +// { dg-prune-output "use of deleted function" }
> diff --git a/libstdc++-v3/testsuite/std/format/string_neg.cc
> b/libstdc++-v3/testsuite/std/format/string_neg.cc
> index 09cc9a25b3e..acae88eaf71 100644
> --- a/libstdc++-v3/testsuite/std/format/string_neg.cc
> +++ b/libstdc++-v3/testsuite/std/format/string_neg.cc
> @@ -8,3 +8,5 @@ auto s = std::format(" {9} "); // { dg-error "call to
> consteval function" }
> struct X { };
> std::format_string<X> str(""); // { dg-error "here" }
> // { dg-error "std::formatter must be specialized" "" { target *-*-* } 0 }
> +
> +// { dg-prune-output "use of deleted function" }
> --
> 2.47.0
>
>
