Ping.
On Fri, Oct 12, 2018 at 12:32:43PM -0400, Marek Polacek wrote:
> On Fri, Oct 12, 2018 at 02:26:45AM -0400, Jason Merrill wrote:
> > On Thu, Oct 11, 2018 at 8:25 PM Marek Polacek <pola...@redhat.com> wrote:
> > >
> > > On Thu, Oct 11, 2018 at 11:35:23AM -0400, Jason Merrill wrote:
> > > > > + /* [dcl.fct.spec]
> > > > > + "the constant-expression, if supplied, shall be a
> > > > > contextually
> > > > > + converted constant expression of type bool." */
> > > > > + expr = build_explicit_specifier (expr, tf_warning_or_error);
> > > > > + /* We could evaluate it -- mark the decl as appropriate. */
> > > > > + if (expr == boolean_true_node)
> > > > > + set_and_check_decl_spec_loc (decl_specs, ds_explicit,
> > > > > token);
> > > > > + else if (explicit_specifier)
> > > > > + /* The expression was value-dependent. Remember it so that
> > > > > we can
> > > > > + substitute it later. */
> > > > > + *explicit_specifier = expr;
> > > >
> > > > What if expr == boolean_false_node?
> > >
> > > Then we proceed like no explicit was present and the decl isn't marked as
> > > explicit/nonconverting. Perhaps I could have made this clearer with
> > >
> > > else if (expr == boolean_true_node)
> > > /* Don't mark the decl as explicit. */;
> > >
> > > or somesuch.
> >
> > Yes, and also so that we don't store the false as a "dependent" specifier.
>
> Oh, absolutely. Fixed.
>
> > > > > + /* Handle explicit(dependent-expr). */
> > > > > + if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t))
> > > > > + {
> > > > > + tree spec = lookup_explicit_specifier (t);
> > > > > + spec = tsubst_copy_and_build (spec, args, complain, in_decl,
> > > > > + /*function_p=*/false,
> > > > > + /*i_c_e_p=*/true);
> > > > > + spec = build_explicit_specifier (spec, complain);
> > > > > + DECL_NONCONVERTING_P (t) = (spec == boolean_true_node);
> > > > > + }
> > > >
> > > > What if spec is still dependent, e.g. after partial substitution of a
> > > > member template?
> > >
> > > Something like this?
> > >
> > > template<typename> struct A {
> > > template<typename T, int N = 0>
> > > explicit(N) operator T();
> > > };
> > >
> > > void
> > > bar ()
> > > {
> > > A<int> a;
> > > int i = a;
> > > }
> > >
> > > This also seemed to work: if spec is still dependent, the decl isn't
> > > marked as
> > > DECL_NONCONVERTING_P, and we'll try again after deduction
> > > (fn_type_unification
> > > in add_template_candidate).
> >
> > Does it also work if N is true? What if the specifier depends on
> > template parameters from both the enclosing class and the member
> > template?
>
> All of that seems to work. I've added explicit12.C and explicit13.C tests to
> cover that. Please check if that's what you had in mind. Thanks,
>
> Bootstrapped/regtested on x86_64-linux, ok for trunk?
>
> 2018-10-12 Marek Polacek <pola...@redhat.com>
>
> Implement P0892R2, explicit(bool).
> * c-cppbuiltin.c (c_cpp_builtins): Define __cpp_explicit_bool.
>
> * call.c (add_template_candidate_real): Return if the declaration is
> explicit and we're only looking for non-converting constructor.
> * cp-tree.h (lang_decl_fn): Add has_dependent_explicit_spec_p bit.
> (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P): New macro.
> (build_explicit_specifier, store_explicit_specifier): Declare.
> * decl.c (build_explicit_specifier): New function.
> * parser.c (cp_parser_decl_specifier_seq): Add explicit_specifier
> parameter. Pass it down to cp_parser_function_specifier_opt.
> (cp_parser_function_specifier_opt): Add explicit_specifier parameter.
> <case RID_EXPLICIT>: Parse C++20 explicit(bool).
> (cp_parser_explicit_instantiation): Update call to
> cp_parser_function_specifier_opt.
> (cp_parser_member_declaration): Have cp_parser_decl_specifier_seq save
> the explicit-specifier. Save it using store_explicit_specifier.
> (cp_parser_single_declaration): Likewise.
> * pt.c (store_explicit_specifier, lookup_explicit_specifier): New.
> (tsubst_function_decl): Handle explicit(dependent-expr).
>
> * g++.dg/cpp2a/explicit1.C: New test.
> * g++.dg/cpp2a/explicit10.C: New test.
> * g++.dg/cpp2a/explicit11.C: New test.
> * g++.dg/cpp2a/explicit12.C: New test.
> * g++.dg/cpp2a/explicit13.C: New test.
> * g++.dg/cpp2a/explicit2.C: New test.
> * g++.dg/cpp2a/explicit3.C: New test.
> * g++.dg/cpp2a/explicit4.C: New test.
> * g++.dg/cpp2a/explicit5.C: New test.
> * g++.dg/cpp2a/explicit6.C: New test.
> * g++.dg/cpp2a/explicit7.C: New test.
> * g++.dg/cpp2a/explicit8.C: New test.
> * g++.dg/cpp2a/explicit9.C: New test.
>
> * testsuite/20_util/any/cons/explicit.cc: Adjust dg-error.
> * testsuite/20_util/pair/cons/explicit_construct.cc: Likewise.
> * testsuite/20_util/tuple/cons/explicit_construct.cc: Likewise.
>
> diff --git gcc/gcc/c-family/c-cppbuiltin.c gcc/gcc/c-family/c-cppbuiltin.c
> index 96a6b4dfd2b..b085cf9201f 100644
> --- gcc/gcc/c-family/c-cppbuiltin.c
> +++ gcc/gcc/c-family/c-cppbuiltin.c
> @@ -955,7 +955,7 @@ c_cpp_builtins (cpp_reader *pfile)
> }
> if (cxx_dialect > cxx14)
> {
> - /* Set feature test macros for C++1z. */
> + /* Set feature test macros for C++17. */
> cpp_define (pfile, "__cpp_unicode_characters=201411");
> cpp_define (pfile, "__cpp_static_assert=201411");
> cpp_define (pfile, "__cpp_namespace_attributes=201411");
> @@ -975,6 +975,11 @@ c_cpp_builtins (cpp_reader *pfile)
> cpp_define (pfile, "__cpp_structured_bindings=201606");
> cpp_define (pfile, "__cpp_variadic_using=201611");
> }
> + if (cxx_dialect > cxx17)
> + {
> + /* Set feature test macros for C++2a. */
> + cpp_define (pfile, "__cpp_explicit_bool=201806");
> + }
> if (flag_concepts)
> cpp_define (pfile, "__cpp_concepts=201507");
> if (flag_tm)
> diff --git gcc/gcc/cp/call.c gcc/gcc/cp/call.c
> index 0baf26e4346..1ae2f0d68a2 100644
> --- gcc/gcc/cp/call.c
> +++ gcc/gcc/cp/call.c
> @@ -3251,6 +3251,12 @@ add_template_candidate_real (struct z_candidate
> **candidates, tree tmpl,
> goto fail;
> }
>
> + /* Now the explicit specifier might have been deduced; check if this
> + declaration is explicit. If it is and we're ignoring non-converting
> + constructors, don't add this function to the set of candidates. */
> + if ((flags & LOOKUP_ONLYCONVERTING) && DECL_NONCONVERTING_P (fn))
> + return NULL;
> +
> if (DECL_CONSTRUCTOR_P (fn) && nargs == 2)
> {
> tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (fn);
> diff --git gcc/gcc/cp/cp-tree.h gcc/gcc/cp/cp-tree.h
> index 26ded3a9214..cf2d0554cb7 100644
> --- gcc/gcc/cp/cp-tree.h
> +++ gcc/gcc/cp/cp-tree.h
> @@ -2587,7 +2587,8 @@ struct GTY(()) lang_decl_fn {
> unsigned this_thunk_p : 1;
> unsigned hidden_friend_p : 1;
> unsigned omp_declare_reduction_p : 1;
> - unsigned spare : 13;
> + unsigned has_dependent_explicit_spec_p : 1;
> + unsigned spare : 12;
>
> /* 32-bits padding on 64-bit host. */
>
> @@ -3033,6 +3034,12 @@ struct GTY(()) lang_decl {
> #define DECL_PURE_VIRTUAL_P(NODE) \
> (LANG_DECL_FN_CHECK (NODE)->pure_virtual)
>
> +/* Nonzero for FUNCTION_DECL means that this member function (either
> + a constructor or a conversion function) has an explicit specifier
> + with a value-dependent expression. */
> +#define DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P(NODE) \
> + (LANG_DECL_FN_CHECK (NODE)->has_dependent_explicit_spec_p)
> +
> /* True (in a FUNCTION_DECL) if NODE is a virtual function that is an
> invalid overrider for a function from a base class. Once we have
> complained about an invalid overrider we avoid complaining about it
> @@ -6375,6 +6382,7 @@ extern tree cxx_maybe_build_cleanup (tree,
> tsubst_flags_t);
> extern bool check_array_designated_initializer (constructor_elt *,
> unsigned HOST_WIDE_INT);
> extern bool check_for_uninitialized_const_var (tree, bool, tsubst_flags_t);
> +extern tree build_explicit_specifier (tree, tsubst_flags_t);
>
> /* in decl2.c */
> extern void record_mangling (tree, bool);
> @@ -6771,6 +6779,7 @@ extern bool dguide_name_p (tree);
> extern bool deduction_guide_p (const_tree);
> extern bool copy_guide_p (const_tree);
> extern bool template_guide_p (const_tree);
> +extern void store_explicit_specifier (tree, tree);
>
> /* in repo.c */
> extern void init_repo (void);
> diff --git gcc/gcc/cp/decl.c gcc/gcc/cp/decl.c
> index 5ebfaaf85e6..f7a2e2a6789 100644
> --- gcc/gcc/cp/decl.c
> +++ gcc/gcc/cp/decl.c
> @@ -16560,4 +16560,20 @@ require_deduced_type (tree decl, tsubst_flags_t
> complain)
> return true;
> }
>
> +/* Create a representation of the explicit-specifier with
> + constant-expression of EXPR. COMPLAIN is as for tsubst. */
> +
> +tree
> +build_explicit_specifier (tree expr, tsubst_flags_t complain)
> +{
> + if (processing_template_decl && value_dependent_expression_p (expr))
> + /* Wait for instantiation, tsubst_function_decl will handle it. */
> + return expr;
> +
> + expr = build_converted_constant_expr (boolean_type_node, expr, complain);
> + expr = instantiate_non_dependent_expr (expr);
> + expr = cxx_constant_value (expr);
> + return expr;
> +}
> +
> #include "gt-cp-decl.h"
> diff --git gcc/gcc/cp/parser.c gcc/gcc/cp/parser.c
> index 76ff83616b0..29a63cd92f6 100644
> --- gcc/gcc/cp/parser.c
> +++ gcc/gcc/cp/parser.c
> @@ -2140,11 +2140,11 @@ static void cp_parser_block_declaration
> static void cp_parser_simple_declaration
> (cp_parser *, bool, tree *);
> static void cp_parser_decl_specifier_seq
> - (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
> + (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *, tree * =
> NULL);
> static tree cp_parser_storage_class_specifier_opt
> (cp_parser *);
> static tree cp_parser_function_specifier_opt
> - (cp_parser *, cp_decl_specifier_seq *);
> + (cp_parser *, cp_decl_specifier_seq *, tree *);
> static tree cp_parser_type_specifier
> (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
> int *, bool *);
> @@ -13513,13 +13513,15 @@ cp_parser_decomposition_declaration (cp_parser
> *parser,
> 2: one of the decl-specifiers is an enum-specifier or a
> class-specifier (i.e., a type definition)
>
> - */
> + EXPLICIT_SPECIFIER is used in case the explicit-specifier, if any, has
> + value-dependent expression. */
>
> static void
> cp_parser_decl_specifier_seq (cp_parser* parser,
> cp_parser_flags flags,
> cp_decl_specifier_seq *decl_specs,
> - int* declares_class_or_enum)
> + int* declares_class_or_enum,
> + tree* explicit_specifier)
> {
> bool constructor_possible_p = !parser->in_declarator_p;
> bool found_decl_spec = false;
> @@ -13640,7 +13642,8 @@ cp_parser_decl_specifier_seq (cp_parser* parser,
> case RID_INLINE:
> case RID_VIRTUAL:
> case RID_EXPLICIT:
> - cp_parser_function_specifier_opt (parser, decl_specs);
> + cp_parser_function_specifier_opt (parser, decl_specs,
> + explicit_specifier);
> break;
>
> /* decl-specifier:
> @@ -13867,12 +13870,17 @@ cp_parser_storage_class_specifier_opt (cp_parser*
> parser)
> virtual
> explicit
>
> + C++2A Extension:
> + explicit(constant-expression)
> +
> Returns an IDENTIFIER_NODE corresponding to the keyword used.
> - Updates DECL_SPECS, if it is non-NULL. */
> + Updates DECL_SPECS, if it is non-NULL. Updates EXPLICIT_SPECIFIER,
> + in case an explicit-specifier is found. */
>
> static tree
> cp_parser_function_specifier_opt (cp_parser* parser,
> - cp_decl_specifier_seq *decl_specs)
> + cp_decl_specifier_seq *decl_specs,
> + tree *explicit_specifier)
> {
> cp_token *token = cp_lexer_peek_token (parser->lexer);
> switch (token->keyword)
> @@ -13893,8 +13901,53 @@ cp_parser_function_specifier_opt (cp_parser* parser,
> break;
>
> case RID_EXPLICIT:
> - set_and_check_decl_spec_loc (decl_specs, ds_explicit, token);
> - break;
> + {
> + tree id = cp_lexer_consume_token (parser->lexer)->u.value;
> + /* If we see '(', it's C++20 explicit(bool). */
> + tree expr;
> + if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
> + {
> + matching_parens parens;
> + parens.consume_open (parser);
> +
> + /* New types are not allowed in an explicit-specifier. */
> + const char *saved_message
> + = parser->type_definition_forbidden_message;
> + parser->type_definition_forbidden_message
> + = G_("types may not be defined in explicit-specifier");
> +
> + if (cxx_dialect < cxx2a)
> + pedwarn (token->location, 0,
> + "%<explicit(bool)%> only available with -std=c++2a "
> + "or -std=gnu++2a");
> +
> + /* Parse the constant-expression. */
> + expr = cp_parser_constant_expression (parser);
> +
> + /* Restore the saved message. */
> + parser->type_definition_forbidden_message = saved_message;
> + parens.require_close (parser);
> + }
> + else
> + /* The explicit-specifier explicit without a constant-expression is
> + equivalent to the explicit-specifier explicit(true). */
> + expr = boolean_true_node;
> +
> + /* [dcl.fct.spec]
> + "the constant-expression, if supplied, shall be a contextually
> + converted constant expression of type bool." */
> + expr = build_explicit_specifier (expr, tf_warning_or_error);
> + /* We could evaluate it -- mark the decl as appropriate. */
> + if (expr == boolean_true_node)
> + set_and_check_decl_spec_loc (decl_specs, ds_explicit, token);
> + else if (expr == boolean_false_node)
> + /* Don't mark the decl as explicit. */;
> + else if (explicit_specifier)
> + /* The expression was value-dependent. Remember it so that we can
> + substitute it later. */
> + *explicit_specifier = expr;
> + return id;
> + }
>
> default:
> return NULL_TREE;
> @@ -16655,7 +16708,8 @@ cp_parser_explicit_instantiation (cp_parser* parser)
> if (!extension_specifier)
> extension_specifier
> = cp_parser_function_specifier_opt (parser,
> - /*decl_specs=*/NULL);
> + /*decl_specs=*/NULL,
> + /*explicit_specifier*/NULL);
> }
>
> /* Look for the `template' keyword. */
> @@ -23569,6 +23623,7 @@ cp_parser_member_declaration (cp_parser* parser)
> cp_token *initializer_token_start = NULL;
> int saved_pedantic;
> bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
> + tree explicit_specifier = NULL_TREE;
>
> /* Check for the `__extension__' keyword. */
> if (cp_parser_extension_opt (parser, &saved_pedantic))
> @@ -23665,7 +23720,8 @@ cp_parser_member_declaration (cp_parser* parser)
> cp_parser_decl_specifier_seq (parser,
> CP_PARSER_FLAGS_OPTIONAL,
> &decl_specifiers,
> - &declares_class_or_enum);
> + &declares_class_or_enum,
> + &explicit_specifier);
> /* Check for an invalid type-name. */
> if (!decl_specifiers.any_type_specifiers_p
> && cp_parser_parse_and_diagnose_invalid_type_name (parser))
> @@ -24019,6 +24075,8 @@ cp_parser_member_declaration (cp_parser* parser)
> /* If the member was not a friend, declare it here. */
> if (!friend_p)
> finish_member_declaration (decl);
> + if (decl && explicit_specifier)
> + store_explicit_specifier (decl, explicit_specifier);
> /* Peek at the next token. */
> token = cp_lexer_peek_token (parser->lexer);
> /* If the next token is a semicolon, consume it. */
> @@ -24048,6 +24106,8 @@ cp_parser_member_declaration (cp_parser* parser)
> else
> decl = finish_fully_implicit_template (parser, decl);
> }
> + if (decl && explicit_specifier)
> + store_explicit_specifier (decl, explicit_specifier);
> }
>
> cp_finalize_omp_declare_simd (parser, decl);
> @@ -27327,6 +27387,7 @@ cp_parser_single_declaration (cp_parser* parser,
> cp_decl_specifier_seq decl_specifiers;
> bool function_definition_p = false;
> cp_token *decl_spec_token_start;
> + tree explicit_specifier = NULL_TREE;
>
> /* This function is only used when processing a template
> declaration. */
> @@ -27342,7 +27403,8 @@ cp_parser_single_declaration (cp_parser* parser,
> cp_parser_decl_specifier_seq (parser,
> CP_PARSER_FLAGS_OPTIONAL,
> &decl_specifiers,
> - &declares_class_or_enum);
> + &declares_class_or_enum,
> + &explicit_specifier);
> if (friend_p)
> *friend_p = cp_parser_friend_p (&decl_specifiers);
>
> @@ -27453,6 +27515,9 @@ cp_parser_single_declaration (cp_parser* parser,
>
> if (decl && VAR_P (decl))
> check_template_variable (decl);
> +
> + if (decl && explicit_specifier)
> + store_explicit_specifier (decl, explicit_specifier);
> }
>
> /* Look for a trailing `;' after the declaration. */
> diff --git gcc/gcc/cp/pt.c gcc/gcc/cp/pt.c
> index f290cb32fc2..c9a3bb0235d 100644
> --- gcc/gcc/cp/pt.c
> +++ gcc/gcc/cp/pt.c
> @@ -12803,6 +12803,28 @@ tsubst_default_arguments (tree fn, tsubst_flags_t
> complain)
> complain);
> }
>
> +/* Hash table mapping a FUNCTION_DECL to its dependent explicit-specifier.
> */
> +static GTY((cache)) tree_cache_map *explicit_specifier_map;
> +
> +/* Store a pair to EXPLICIT_SPECIFIER_MAP. */
> +
> +void
> +store_explicit_specifier (tree v, tree t)
> +{
> + if (!explicit_specifier_map)
> + explicit_specifier_map = tree_cache_map::create_ggc (37);
> + DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (v) = true;
> + explicit_specifier_map->put (v, t);
> +}
> +
> +/* Lookup an element in EXPLICIT_SPECIFIER_MAP. */
> +
> +static tree
> +lookup_explicit_specifier (tree v)
> +{
> + return *explicit_specifier_map->get (v);
> +}
> +
> /* Subroutine of tsubst_decl for the case when T is a FUNCTION_DECL. */
>
> static tree
> @@ -12822,6 +12844,17 @@ tsubst_function_decl (tree t, tree args,
> tsubst_flags_t complain,
> if (!uses_template_parms (DECL_TI_ARGS (t)))
> return t;
>
> + /* Handle explicit(dependent-expr). */
> + if (DECL_HAS_DEPENDENT_EXPLICIT_SPEC_P (t))
> + {
> + tree spec = lookup_explicit_specifier (t);
> + spec = tsubst_copy_and_build (spec, args, complain, in_decl,
> + /*function_p=*/false,
> + /*i_c_e_p=*/true);
> + spec = build_explicit_specifier (spec, complain);
> + DECL_NONCONVERTING_P (t) = (spec == boolean_true_node);
> + }
> +
> /* Calculate the most general template of which R is a
> specialization. */
> gen_tmpl = most_general_template (DECL_TI_TEMPLATE (t));
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit1.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit1.C
> index e69de29bb2d..b39f90f3397 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit1.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit1.C
> @@ -0,0 +1,63 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +constexpr int fn0 () { return 0; }
> +constexpr int fn1 () { return 1; }
> +
> +struct S {
> + explicit(true) S(int);
> + explicit(1 == 0) S(int, int);
> + explicit(fn0()) S(int, int, int);
> + explicit(fn1()) S(int, int, int, int);
> +};
> +
> +struct X {
> + static const bool value = true;
> + static constexpr bool foo () { return 1; }
> +};
> +
> +struct T {
> + explicit(true ? 1 : throw 1) T(int);
> + explicit(true || true ? 1 : throw 1) T(int, int);
> + explicit(X::value) T(int, int, int);
> + explicit(X::foo ()) T(int, int, int, int);
> +};
> +
> +struct W {
> + constexpr operator bool() { return true; };
> +};
> +
> +struct W2 {
> + constexpr operator bool() { return false; };
> +};
> +
> +struct U {
> + explicit(W()) U(int);
> + explicit(W2()) U(int, int);
> +};
> +
> +int
> +main ()
> +{
> + S s1 = { 1 }; // { dg-error "converting" }
> + S s1x{ 1 };
> + S s2 = { 2, 3 };
> + S s3 = { 4, 5, 6 };
> + S s4 = { 7, 8, 9, 10 }; // { dg-error "converting" }
> + S s4x{ 7, 8, 9, 10 };
> +
> + T t1 = { 1 }; // { dg-error "converting" }
> + T t2 = { 1, 2 }; // { dg-error "converting" }
> + T t3 = { 1, 2, 3 }; // { dg-error "converting" }
> + T t4 = { 1, 2, 3, 4 }; // { dg-error "converting" }
> + T t5{ 1 };
> + T t6{ 1, 2 };
> + T t7{ 1, 2, 3 };
> + T t8{ 1, 2, 3, 4 };
> +
> + U u1 = { 1 }; // { dg-error "converting" }
> + U u2{ 1 };
> + U u3 = { 1, 2 };
> + U u4 { 1, 2 };
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit10.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit10.C
> index e69de29bb2d..c8701551c9a 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit10.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit10.C
> @@ -0,0 +1,32 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +#include <type_traits>
> +
> +class A {};
> +class B : public A {};
> +class C {};
> +class D { public: operator C() { return c; } C c; };
> +
> +template <typename T1, typename T2>
> +struct S {
> + explicit(!std::is_convertible_v<T1, T2>)
> + S(T1, T2) { }
> +};
> +
> +void
> +foo ()
> +{
> + A a;
> + B b;
> + C c;
> + D d;
> +
> + S<int, int> s{ 1, 2 };
> + S<int, int> s2 = { 1, 2 };
> + S<B*, A*> s3 = { &b, &a };
> + S<A*, B*> s4 = { &a, &b }; // { dg-error "converting" }
> + S<B*, C*> s5 = { &b, &c }; // { dg-error "converting" }
> + S<D, C> s6 = { d, c };
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit11.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit11.C
> index e69de29bb2d..ad1bed5b3f0 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit11.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit11.C
> @@ -0,0 +1,29 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a -pedantic" }
> +
> +template<typename T>
> +struct A {
> + explicit A(const T&, ...) noexcept;
> + A(T&&, ...);
> +};
> +
> +int i;
> +A a1 = { i, i }; // { dg-error "deduction|cannot" }
> +A a2{ i, i };
> +A a3{ 0, i };
> +A a4 = { 0, i };
> +
> +template<typename T> A(const T&, const T&) -> A<T&>;
> +template<typename T> explicit A(T&&, T&&) -> A<T>;
> +
> +A a5 = { 0, 1 }; // { dg-error "deduction|ambiguous" }
> +A a6{ 0, 1 };
> +
> +template<typename T>
> +struct B {
> + template<typename U> using TA = T;
> + template<typename U> B(U, TA<U>);
> +};
> +
> +B b{(int *)0, (char *)0};
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit12.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit12.C
> index e69de29bb2d..6db3157580b 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit12.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit12.C
> @@ -0,0 +1,23 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +template<typename> struct A {
> + template<typename T, int N = 0>
> + explicit(N) operator T();
> +};
> +
> +template<typename> struct B {
> + template<typename T, int N = 1>
> + explicit(N) operator T();
> +};
> +
> +void
> +bar ()
> +{
> + A<int> a;
> + int i = a;
> +
> + B<int> b;
> + int j = b; // { dg-error "cannot convert" }
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit13.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit13.C
> index e69de29bb2d..4747ebd3df4 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit13.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit13.C
> @@ -0,0 +1,35 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +template<int M = 0> struct A {
> + template<typename T, int N = 0>
> + explicit(N + M) operator T();
> +};
> +
> +template<int M = 1> struct B {
> + template<typename T, int N = 1>
> + explicit(N * M) operator T();
> +};
> +
> +void
> +bar ()
> +{
> + A a;
> + int i = a;
> +
> + A<0> a0;
> + int i0 = a0;
> +
> + A<1> a1;
> + int i1 = a1; // { dg-error "cannot convert" }
> +
> + B b;
> + int j = b; // { dg-error "cannot convert" }
> +
> + B<0> b0;
> + int j0 = b0;
> +
> + B<1> b1;
> + int j1 = b1; // { dg-error "cannot convert" }
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit2.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit2.C
> index e69de29bb2d..7d1748c0f5e 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit2.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit2.C
> @@ -0,0 +1,25 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +int foo() { return 42; }
> +int g;
> +
> +struct S {
> + explicit(foo()) S(int); // { dg-error "call to" }
> + explicit(int) S(int, int); // { dg-error "expected" }
> + explicit(false ? 1 : throw 1) S(int, int, int); // { dg-error "not a
> constant" }
> +};
> +
> +struct S2 {
> + explicit(true) S2();
> + explicit(false) S2(); // { dg-error "cannot be overloaded" }
> +};
> +
> +int
> +main ()
> +{
> + S s1 = { 1 };
> + S s2 = { 1, 2 }; // { dg-error "could not convert" }
> + S s3 = { 1, 2, 3 };
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit3.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit3.C
> index e69de29bb2d..7c495a3640b 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit3.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit3.C
> @@ -0,0 +1,24 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +#include <type_traits>
> +
> +template <typename T1, typename T2>
> +struct pair {
> + template <typename U1=T1, typename U2=T2,
> + std::enable_if_t<
> + std::is_constructible_v<T1, U1> &&
> + std::is_constructible_v<T2, U2>
> + , int> = 0>
> + explicit(!std::is_convertible_v<U1, T1> ||
> + !std::is_convertible_v<U2, T2>)
> + constexpr pair(U1&&, U2&&) { }
> +};
> +
> +void
> +foo ()
> +{
> + pair<int, int> p{1, 2};
> + pair<int, int> p2 = {1, 2};
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit4.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit4.C
> index e69de29bb2d..822a1f155b4 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit4.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit4.C
> @@ -0,0 +1,41 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +template<int T = 1>
> +struct S {
> + explicit(T) S(int);
> + explicit(!T) S(int, int);
> +};
> +
> +template<typename T, int N>
> +struct S2 {
> + explicit(N) S2(T);
> +};
> +
> +template<typename T>
> +struct S3 {
> + explicit((T) 1.0) S3(int);
> +};
> +
> +int
> +main ()
> +{
> + S<> s1 = { 1 }; // { dg-error "converting" }
> + S<true> s2 = { 1 }; // { dg-error "converting" }
> + S<false> s3 = { 1 };
> + S<> s4{ 1 };
> + S<true> s5{ 1 };
> + S<> s6 = { 1, 2 };
> + S<true> s7 = { 1, 2 };
> + S<false> s8 = { 1, 2 }; // { dg-error "converting" }
> + S<false> s9{ 1, 2 };
> +
> + const int x = 1;
> + S<x> s10 = { 1 }; // { dg-error "converting" }
> + S<x> s11{ 2 };
> +
> + S2<int, true> s12 = { 1 }; // { dg-error "converting" }
> +
> + S3<int> s13 = { 1 }; // { dg-error "converting" }
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit5.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit5.C
> index e69de29bb2d..70a106f1fcb 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit5.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit5.C
> @@ -0,0 +1,71 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +constexpr int fn0 () { return 0; }
> +constexpr int fn1 () { return 1; }
> +
> +struct S0 {
> + explicit(false) operator int();
> + explicit(1 == 0) operator double();
> + explicit(fn0()) operator char();
> +};
> +
> +struct S1 {
> + explicit(true) operator int();
> + explicit(1 == 1) operator double();
> + explicit(fn1()) operator char();
> +};
> +
> +struct X {
> + static const bool value = true;
> + static constexpr bool foo () { return 1; }
> +};
> +
> +struct T {
> + explicit(true ? 1 : throw 1) operator int();
> + explicit(true || true ? 1 : throw 1) operator double();
> + explicit(X::value) operator char();
> + explicit(X::foo ()) operator long();
> +};
> +
> +struct W {
> + constexpr operator bool() { return true; };
> +};
> +
> +struct W2 {
> + constexpr operator bool() { return false; };
> +};
> +
> +struct U1 {
> + explicit(W()) operator int();
> +};
> +
> +struct U2 {
> + explicit(W2()) operator int();
> +};
> +
> +int
> +main ()
> +{
> + S0 s0;
> + S1 s1;
> + int i0 = s0;
> + int i1 = s1; // { dg-error "cannot convert" }
> + double d0 = s0;
> + double d1 = s1; // { dg-error "cannot convert" }
> + char c0 = s0;
> + char c1 = s1; // { dg-error "cannot convert" }
> +
> + T t;
> + int i2 = t; // { dg-error "cannot convert" }
> + double d2 = t; // { dg-error "cannot convert" }
> + char c2 = t; // { dg-error "cannot convert" }
> + long l1 = t; // { dg-error "cannot convert" }
> +
> + U1 u1;
> + int i3 = u1; // { dg-error "cannot convert" }
> +
> + U2 u2;
> + int i4 = u2;
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit6.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit6.C
> index e69de29bb2d..10134680ed3 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit6.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit6.C
> @@ -0,0 +1,41 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +template<int T = 1>
> +struct S {
> + explicit(T) operator int();
> +};
> +
> +template<typename T, int N>
> +struct R {
> + explicit(N) operator T();
> +};
> +
> +template<typename T>
> +struct U {
> + explicit((T) 1.0) operator T();
> +};
> +
> +int
> +main ()
> +{
> + S s;
> + int i1 = s; // { dg-error "cannot convert" }
> + S<true> s2;
> + int i2 = s2; // { dg-error "cannot convert" }
> + S<false> s3;
> + int i3 = s3;
> + int i4{s};
> + int i5{s2};
> + int i6{s3};
> +
> + R<int, true> r;
> + int i7 = r; // { dg-error "cannot convert" }
> + R<int, false> r2;
> + int i8 = r2;
> +
> + U<int> u;
> + int i9 = u; // { dg-error "cannot convert" }
> + int i10{u};
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit7.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit7.C
> index e69de29bb2d..dfa4e138d4c 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit7.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit7.C
> @@ -0,0 +1,22 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +template<typename T>
> +struct B {
> + static const T value = true;
> +};
> +
> +struct X {
> + template<typename T>
> + explicit(B<T>::value) operator T();
> +};
> +
> +int
> +main ()
> +{
> + X x;
> + int i = x.operator int();
> + int i3 = x; // { dg-error "cannot convert" }
> + int i2{x};
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit8.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit8.C
> index e69de29bb2d..bf2f9ed9917 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit8.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit8.C
> @@ -0,0 +1,24 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a" }
> +
> +struct X {
> + template<typename T, int N = 1>
> + explicit(N) operator T();
> +};
> +
> +int
> +main ()
> +{
> + X x;
> + int i = x; // { dg-error "cannot convert" }
> + int i2{x};
> + double d = x; // { dg-error "cannot convert" }
> + double d2{x};
> + char c = x; // { dg-error "cannot convert" }
> + char c2{x};
> + long l = x; // { dg-error "cannot convert" }
> + long l2{x};
> + int *p = x; // { dg-error "cannot convert" }
> + int *p2{x};
> +}
> diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit9.C
> gcc/gcc/testsuite/g++.dg/cpp2a/explicit9.C
> index e69de29bb2d..6568e5c6661 100644
> --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit9.C
> +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit9.C
> @@ -0,0 +1,22 @@
> +// P0892R2
> +// { dg-do compile }
> +// { dg-options "-std=c++2a -fconcepts" }
> +
> +#include <type_traits>
> +
> +template <typename T1, typename T2>
> +struct pair {
> + template <typename U1=T1, typename U2=T2>
> + requires std::is_constructible_v<T1, U1> &&
> + std::is_constructible_v<T2, U2>
> + explicit(!std::is_convertible_v<U1, T1> ||
> + !std::is_convertible_v<U2, T2>)
> + constexpr pair(U1&&, U2&&) { }
> +};
> +
> +void
> +foo ()
> +{
> + pair<int, int> p{1, 2};
> + pair<int, int> p2 = {1, 2};
> +}
> diff --git gcc/libstdc++-v3/testsuite/20_util/any/cons/explicit.cc
> gcc/libstdc++-v3/testsuite/20_util/any/cons/explicit.cc
> index f5425e09fba..3c13a86a2c9 100644
> --- gcc/libstdc++-v3/testsuite/20_util/any/cons/explicit.cc
> +++ gcc/libstdc++-v3/testsuite/20_util/any/cons/explicit.cc
> @@ -24,7 +24,7 @@
>
> int main()
> {
> - std::any a = {std::in_place_type<int>, 42}; // { dg-error "converting" }
> + std::any a = {std::in_place_type<int>, 42}; // { dg-error "convert" }
> std::any a2 = {std::in_place_type<std::vector<int>>,
> - {42, 666}}; // { dg-error "converting" }
> + {42, 666}}; // { dg-error "convert" }
> }
> diff --git gcc/libstdc++-v3/testsuite/20_util/pair/cons/explicit_construct.cc
> gcc/libstdc++-v3/testsuite/20_util/pair/cons/explicit_construct.cc
> index 67603fb706f..6185ed6cdbc 100644
> --- gcc/libstdc++-v3/testsuite/20_util/pair/cons/explicit_construct.cc
> +++ gcc/libstdc++-v3/testsuite/20_util/pair/cons/explicit_construct.cc
> @@ -37,7 +37,7 @@ struct ExplicitDefaultDefault
>
> std::pair<int, int> f1() {return {1,2};}
>
> -std::pair<Explicit, Explicit> f2() {return {1,2};} // { dg-error "explicit" }
> +std::pair<Explicit, Explicit> f2() {return {1,2};} // { dg-error "could not
> convert" }
>
> std::pair<long, long> f3() {return std::pair<int, int>{1,2};}
>
> @@ -52,7 +52,7 @@ std::pair<int, int> v0{1,2};
>
> std::pair<Explicit, Explicit> v1{1,2};
>
> -std::pair<Explicit, Explicit> v2 = {1,2}; // { dg-error "explicit" }
> +std::pair<Explicit, Explicit> v2 = {1,2}; // { dg-error "could not convert" }
>
> std::pair<Explicit, Explicit> v3{std::pair<int,int>{1,2}};
>
> @@ -83,12 +83,12 @@ void f7(std::pair<long, long>) {}
>
> std::pair<ExplicitDefault, int> f8()
> {
> - return {}; // { dg-error "explicit" }
> + return {}; // { dg-error "could not convert" }
> }
>
> std::pair<ExplicitDefaultDefault, int> f9()
> {
> - return {}; // { dg-error "explicit" }
> + return {}; // { dg-error "could not convert" }
> }
>
> void f10(std::pair<ExplicitDefault, int>) {}
> @@ -99,7 +99,7 @@ void test_arg_passing()
> {
> f6(v0); // { dg-error "could not convert" }
> f6(v1);
> - f6({1,2}); // { dg-error "explicit" }
> + f6({1,2}); // { dg-error "could not convert" }
> f6(std::pair<Explicit, Explicit>{});
> f6(std::pair<int, int>{}); // { dg-error "could not convert" }
> f7(v0);
> @@ -107,8 +107,8 @@ void test_arg_passing()
> f7({1,2});
> f7(std::pair<int, int>{});
> f7(std::pair<long, long>{});
> - f10({}); // { dg-error "explicit" }
> - f11({}); // { dg-error "explicit" }
> + f10({}); // { dg-error "could not convert" }
> + f11({}); // { dg-error "could not convert" }
> f10(std::pair<ExplicitDefault, int>{});
> f11(std::pair<ExplicitDefaultDefault, int>{});
> }
> @@ -130,6 +130,6 @@ std::pair<int*, ExplicitMoveOnly> v14{0, MoveOnly{}};
> std::pair<ExplicitMoveOnly, int*> v15{MoveOnly{}, 0};
>
> std::pair<int*, ExplicitMoveOnly> v16 =
> - {0, MoveOnly{}}; // { dg-error "explicit" }
> + {0, MoveOnly{}}; // { dg-error "could not convert" }
> std::pair<ExplicitMoveOnly, int*> v17 =
> - {MoveOnly{}, 0}; // { dg-error "explicit" }
> + {MoveOnly{}, 0}; // { dg-error "could not convert" }
> diff --git
> gcc/libstdc++-v3/testsuite/20_util/tuple/cons/explicit_construct.cc
> gcc/libstdc++-v3/testsuite/20_util/tuple/cons/explicit_construct.cc
> index 2b1de37bb62..6874be40f71 100644
> --- gcc/libstdc++-v3/testsuite/20_util/tuple/cons/explicit_construct.cc
> +++ gcc/libstdc++-v3/testsuite/20_util/tuple/cons/explicit_construct.cc
> @@ -43,11 +43,11 @@ std::tuple<int, int> f1b() {return {1,2};}
> std::tuple<int, int, int> f1c() {return {1,2,3};}
>
> std::tuple<Explicit> f2_a()
> -{return {1};} // { dg-error "explicit" }
> +{return {1};} // { dg-error "could not convert" }
> std::tuple<Explicit, Explicit> f2_b()
> -{return {1,2};} // { dg-error "explicit" }
> +{return {1,2};} // { dg-error "could not convert" }
> std::tuple<Explicit, Explicit, Explicit> f2_c()
> -{return {1,2,3};} // { dg-error "explicit" }
> +{return {1,2,3};} // { dg-error "could not convert" }
>
> std::tuple<long> f3_a() {return std::tuple<int>{1};}
> std::tuple<long, long> f3_b() {return std::tuple<int, int>{1,2};}
> @@ -71,22 +71,22 @@ std::tuple<long, long> f5_b() {return {1,2};}
> std::tuple<long, long, long> f5_c() {return {1,2,3};}
>
> std::tuple<ExplicitDefault> f6_a()
> -{return {};} // { dg-error "explicit" }
> +{return {};} // { dg-error "could not convert" }
> std::tuple<ExplicitDefault, ExplicitDefault> f6_b()
> -{return {};} // { dg-error "explicit" }
> +{return {};} // { dg-error "could not convert" }
> std::tuple<ExplicitDefault, ExplicitDefault, ExplicitDefault> f6_c()
> -{return {};} // { dg-error "explicit" }
> +{return {};} // { dg-error "could not convert" }
> std::tuple<ExplicitDefault, int> f6_d()
> -{return {};} // { dg-error "explicit" }
> +{return {};} // { dg-error "could not convert" }
>
> std::tuple<ExplicitDefaultDefault> f7_a()
> -{return {};} // { dg-error "explicit" }
> +{return {};} // { dg-error "could not convert" }
> std::tuple<ExplicitDefaultDefault, ExplicitDefaultDefault> f7_b()
> -{return {};} // { dg-error "explicit" }
> +{return {};} // { dg-error "could not convert" }
> std::tuple<ExplicitDefaultDefault,
> ExplicitDefaultDefault,
> ExplicitDefaultDefault> f7_c()
> -{return {};} // { dg-error "explicit" }
> +{return {};} // { dg-error "could not convert" }
>
> std::tuple<int, int> fp1() {return std::pair<int, int>{1,2}; }
> std::tuple<long, long> fp2() {return std::pair<int, int>{1,2}; }
> @@ -101,9 +101,9 @@ std::tuple<Explicit> v1_a{1};
> std::tuple<Explicit, Explicit> v1_b{1,2};
> std::tuple<Explicit, Explicit, Explicit> v1_c{1,2,3};
>
> -std::tuple<Explicit> v2_a = {1}; // { dg-error "explicit" }
> -std::tuple<Explicit, Explicit> v2_b = {1,2}; // { dg-error "explicit" }
> -std::tuple<Explicit, Explicit, Explicit> v2_c = {1,2,3}; // { dg-error
> "explicit" }
> +std::tuple<Explicit> v2_a = {1}; // { dg-error "could not convert" }
> +std::tuple<Explicit, Explicit> v2_b = {1,2}; // { dg-error "could not
> convert" }
> +std::tuple<Explicit, Explicit, Explicit> v2_c = {1,2,3}; // { dg-error
> "could not convert" }
>
> std::tuple<Explicit> v3_a{std::tuple<int>{1}};
> std::tuple<Explicit, Explicit> v3_b{std::tuple<int,int>{1,2}};
> @@ -194,11 +194,11 @@ std::tuple<long, long, long>
> v31_c{std::allocator_arg, std::allocator<int>{}, 1,2,3};
>
> std::tuple<Explicit> v32_a
> - = {std::allocator_arg, std::allocator<int>{ }, 1}; // { dg-error
> "explicit" }
> + = {std::allocator_arg, std::allocator<int>{ }, 1}; // { dg-error "could
> not convert" }
> std::tuple<Explicit, Explicit> v32_b
> - = {std::allocator_arg, std::allocator<int>{}, 1, 2}; // { dg-error
> "explicit" }
> + = {std::allocator_arg, std::allocator<int>{}, 1, 2}; // { dg-error "could
> not convert" }
> std::tuple<Explicit, Explicit, Explicit> v32_c
> - = {std::allocator_arg, std::allocator<int>{}, 1,2,3}; // { dg-error
> "explicit" }
> + = {std::allocator_arg, std::allocator<int>{}, 1,2,3}; // { dg-error "could
> not convert" }
>
> std::tuple<int, int> v33{std::allocator_arg, std::allocator<int>{},
> std::pair<int, int>{1, 2}};
> @@ -216,7 +216,7 @@ std::tuple<long, long> v37 = {std::allocator_arg,
> std::allocator<int>{},
> std::pair<int, int>{1, 2}};
>
> std::tuple<Explicit, Explicit> v38
> -= {std::allocator_arg, std::allocator<int>{}, std::pair<int, int>{1, 2}}; //
> { dg-error "explicit" }
> += {std::allocator_arg, std::allocator<int>{}, std::pair<int, int>{1, 2}}; //
> { dg-error "could not convert" }
>
> std::tuple<int, int> v39{std::allocator_arg, std::allocator<int>{}, v20};
>
> @@ -230,18 +230,18 @@ std::tuple<int, int> v42 = {std::allocator_arg,
> std::allocator<int>{}, v20};
> std::tuple<long, long> v43 = {std::allocator_arg, std::allocator<int>{},
> v20};
>
> std::tuple<Explicit, Explicit> v44
> -= {std::allocator_arg, std::allocator<int>{ }, v20}; // { dg-error
> "explicit" }
> += {std::allocator_arg, std::allocator<int>{ }, v20}; // { dg-error "could
> not convert" }
> std::tuple<ExplicitDefault> v45_a{};
> std::tuple<ExplicitDefault, int> v45_b{};
>
> -std::tuple<ExplicitDefault> v46_a = {}; // { dg-error "explicit" }
> -std::tuple<ExplicitDefault, int> v46_b = {}; // { dg-error "explicit" }
> +std::tuple<ExplicitDefault> v46_a = {}; // { dg-error "could not convert" }
> +std::tuple<ExplicitDefault, int> v46_b = {}; // { dg-error "could not
> convert" }
>
> std::tuple<ExplicitDefaultDefault> v47_a{};
> std::tuple<ExplicitDefaultDefault, int> v47_b{};
>
> -std::tuple<ExplicitDefaultDefault> v48_a = {}; // { dg-error "explicit" }
> -std::tuple<ExplicitDefaultDefault, int> v48_b = { }; // { dg-error
> "explicit" }
> +std::tuple<ExplicitDefaultDefault> v48_a = {}; // { dg-error "could not
> convert" }
> +std::tuple<ExplicitDefaultDefault, int> v48_b = { }; // { dg-error "could
> not convert" }
>
>
> struct DeletedCopy
> @@ -293,9 +293,9 @@ void test_arg_passing()
> f8_b(v1_b);
> f8_c(v1_c);
>
> - f8_a({1}); // { dg-error "explicit" }
> - f8_b({1,2}); // { dg-error "explicit" }
> - f8_c({1,2,3}); // { dg-error "explicit" }
> + f8_a({1}); // { dg-error "could not convert" }
> + f8_b({1,2}); // { dg-error "could not convert" }
> + f8_c({1,2,3}); // { dg-error "could not convert" }
>
> f8_a(std::tuple<Explicit>{});
> f8_b(std::tuple<Explicit, Explicit>{});
> @@ -328,10 +328,10 @@ void test_arg_passing()
> f9_b(std::tuple<long, long>{});
> f9_c(std::tuple<long, long, long>{});
>
> - f10_a({}); // { dg-error "explicit" }
> - f10_b({}); // { dg-error "explicit" }
> - f11_a({}); // { dg-error "explicit" }
> - f11_b({}); // { dg-error "explicit" }
> + f10_a({}); // { dg-error "could not convert" }
> + f10_b({}); // { dg-error "could not convert" }
> + f11_a({}); // { dg-error "could not convert" }
> + f11_b({}); // { dg-error "could not convert" }
>
> f10_a(std::tuple<ExplicitDefault>{});
> f10_b(std::tuple<ExplicitDefault, int>{});
Marek
