This patch implements C++20 explicit(bool), as described in: <http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0892r2.html>.
I tried to follow the noexcept specifier implementation where I could, which made the non-template parts of this fairly easy. To make explicit(expr) work with dependent expressions, I had to add DECL_EXPLICIT_SPEC to lang_decl_fn, which serves as a vessel to get the explicit-specifier to tsubst_function_decl where I substitute the dependent arguments. I've written a bunch of tests testing the basic functionality but I don't doubt I've missed a couple of important scenarios. I hope we can shake those out as people start playing with this feature. Bootstrapped/regtested on x86_64-linux, ok for trunk? 2018-10-01 Marek Polacek <pola...@redhat.com> 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 explicit_specifier field. (DECL_EXPLICIT_SPEC): New macro. (build_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 to DECL_EXPLICIT_SPEC. (cp_parser_single_declaration): Likewise. * pt.c (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/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 b2ca667c8b4..7003a4a2f50 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 efbdad83966..6cee257b8a7 100644 --- gcc/gcc/cp/cp-tree.h +++ gcc/gcc/cp/cp-tree.h @@ -2604,6 +2604,10 @@ struct GTY(()) lang_decl_fn { will be chained on the return pointer thunk. */ tree context; + /* Explicit-specifier, if any. Only constructors or conversion + functions can have it. */ + tree explicit_specifier; + union lang_decl_u5 { /* In a non-thunk FUNCTION_DECL or TEMPLATE_DECL, this is @@ -4501,6 +4505,10 @@ more_aggr_init_expr_args_p (const aggr_init_expr_arg_iterator *iter) #define DECL_GLOBAL_DTOR_P(NODE) \ (LANG_DECL_FN_CHECK (NODE)->global_dtor_p) +/* Explicit-specifier for this FUNCTION_DECL. */ +#define DECL_EXPLICIT_SPEC(NODE) \ + (LANG_DECL_FN_CHECK (NODE)->explicit_specifier) + /* Accessor macros for C++ template decl nodes. */ /* The DECL_TEMPLATE_PARMS are a list. The TREE_PURPOSE of each node @@ -6366,6 +6374,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); diff --git gcc/gcc/cp/decl.c gcc/gcc/cp/decl.c index 2d9d56ef6e1..1a783d556de 100644 --- gcc/gcc/cp/decl.c +++ gcc/gcc/cp/decl.c @@ -16554,4 +16554,21 @@ 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 take care of it. */ + return expr; + + expr = perform_implicit_conversion_flags (boolean_type_node, expr, + complain, LOOKUP_NORMAL); + 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 6696f174d75..b248a51e80f 100644 --- gcc/gcc/cp/parser.c +++ gcc/gcc/cp/parser.c @@ -2141,11 +2141,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 *); @@ -13515,13 +13515,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; @@ -13642,7 +13644,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: @@ -13869,12 +13872,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) @@ -13895,8 +13903,51 @@ 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 (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; @@ -16657,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. */ @@ -23567,6 +23619,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)) @@ -23663,7 +23716,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)) @@ -24017,6 +24071,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) + DECL_EXPLICIT_SPEC (decl) = explicit_specifier; /* Peek at the next token. */ token = cp_lexer_peek_token (parser->lexer); /* If the next token is a semicolon, consume it. */ @@ -24046,6 +24102,8 @@ cp_parser_member_declaration (cp_parser* parser) else decl = finish_fully_implicit_template (parser, decl); } + if (decl && explicit_specifier) + DECL_EXPLICIT_SPEC (decl) = explicit_specifier; } cp_finalize_omp_declare_simd (parser, decl); @@ -27325,6 +27383,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. */ @@ -27340,7 +27399,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); @@ -27451,6 +27511,9 @@ cp_parser_single_declaration (cp_parser* parser, if (decl && VAR_P (decl)) check_template_variable (decl); + + if (decl && explicit_specifier) + DECL_EXPLICIT_SPEC (decl) = explicit_specifier; } /* Look for a trailing `;' after the declaration. */ diff --git gcc/gcc/cp/pt.c gcc/gcc/cp/pt.c index b8b6545434b..3a7424ffb0f 100644 --- gcc/gcc/cp/pt.c +++ gcc/gcc/cp/pt.c @@ -12822,6 +12822,18 @@ 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). */ + tree explicit_spec = DECL_EXPLICIT_SPEC (t); + if (explicit_spec) + { + explicit_spec = tsubst_copy_and_build (explicit_spec, args, complain, + in_decl, + /*function_p=*/false, + /*i_c_e_p=*/true); + explicit_spec = build_explicit_specifier (explicit_spec, complain); + DECL_NONCONVERTING_P (t) = (explicit_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..f0ee7c3de23 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 42; } + +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/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..c491bd0808f 100644 --- gcc/gcc/testsuite/g++.dg/cpp2a/explicit4.C +++ gcc/gcc/testsuite/g++.dg/cpp2a/explicit4.C @@ -0,0 +1,42 @@ +// 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 = 4; + 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" } + S3<double> s14 = { 1 }; // { dg-error "converting" } +} diff --git gcc/gcc/testsuite/g++.dg/cpp2a/explicit5.C gcc/gcc/testsuite/g++.dg/cpp2a/explicit5.C index e69de29bb2d..ebfe412508b 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 42; } + +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>{});