From 5ade1ed2c08bf2f327ee24afc57bc263fd90e6e1 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Tue, 25 Mar 2008 13:53:58 +0000 Subject: [PATCH] typeck.c (composite_pointer_type_r): Add SFINAE support. 2008-03-25 Douglas Gregor * typeck.c (composite_pointer_type_r): Add SFINAE support. (composite_pointer_type): Ditto. (common_type): Fix call to composite_pointer_type. (cxx_sizeof_nowarn): New; used to be a macro. (cxx_sizeof_expr): Add SFINAE support. (cxx_alignof_expr): Ditto. (decay_conversion): Fix calls for SFINAE support. (rationalize_conditional_expr): Add SFINAE support. (build_class_member_access_expr): Ditto. (finish_class_member_access_expr): Ditto. (build_x_indirect_ref): Ditto. (build_indirect_ref): Original version renamed to cp_build_indirect_ref; new version provides a bridge from c-common. (cp_build_indirect_ref): Was build_indirect_ref; added SFINAE support. (get_member_function_from_ptrfunc): Fix calls for SFINAE support. (build_function_call): Original version renamed to cp_build_function_call; new version provides a bridge from c-common. (cp_build_function_call): Was build_function_call; added SFINAE support. (convert_arguments): Add SFINAE support. (build_x_binary_op): Ditto. (build_binary_op): Original version renamed to cp_build_binary_op; new version provides a bridge from c-common. (cp_build_binary_op): Was build_binary_op; added SFINAE support. (pointer_diff): Fix calls for SFINAE. (build_x_unary_op): Add SFINAE support. (condition_conversion): Fix calls for SFINAE. (build_unary_op): Original version renamed to cp_build_unary_op; new version provides a bridge from c-common. (cp_build_unary_op): Was build_unary_op; added SFINAE support. (unary_complex_lvalue): Fix calls for SFINAE. (build_x_conditional_expr): Add SFINAE support. (build_x_compound_expr_from_list): Fix calls for SFINAE. (build_x_compound_expr): Add SFINAE support. (convert_ptrmem): Fix calls for SFINAE. (build_static_cast_1): Add SFINAE support. (build_static_cast): Ditto. (build_reinterpret_cast_1): Ditto. (build_reinterpret_cast): Ditto. (build_const_cast_1): Ditto. (build_const_cast): Ditto. (build_c_cast): Ditto. (build_modify_expr): Original version renamed to cp_build_modify_expr; new version provides a bridge from c-common. (cp_build_modify_expr): Was build_modify_expr; added SFINAE support. (build_x_modify_expr): Add SFINAE support. (build_ptrmemfunc): Fix calls for SFINAE. (convert_for_assignment): Add SFINAE support. (convert_for_initialization): Ditto. (check_return_expr): Fix calls for SFINAE. (lvalue_or_else): Add SFINAE support. * init.c (perform_member_init): Fix calls for SFINAE. (emit_mem_initializers): Ditto. (expand_virtual_init): Ditto. (expand_cleanup_for_base): Ditto. (build_aggr_init): Add SFINAE support. (expand_default_init): Ditto. (expand_aggr_init_1): Fix calls for SFINAE. (build_offset_ref): Ditto. (build_new_1): Add SFINAE support. (build_new): Ditto. (build_vec_delete_1): Fix calls for SFINAE. (get_temp_regvar): Ditto. (build_vec_init): Add SFINAE support. (build_dtor_call): Fix calls for SFINAE. (build_delete): Ditto. (push_base_cleanups): Ditto. (build_vec_delete_1): Ditto. * class.c (build_base_path): Fix calls for SFINAE. (build_simple_base_path): Ditto. (convert_to_base_statically): Ditto. (build_vfn_ref): Ditto. (resolve_address_of_overloaded_function): Ditto. * decl.c (check_initializer): Fix calls for SFINAE. (register_dtor_fn): Ditto. (compute_array_index_type): Ditto. (finish_enum): Ditto. (start_preparsed_function): Ditto. (cxx_maybe_build_cleanup): Ditto. * call.c (convert_like): Add COMPLAIN argument. (convert_like_with_context): Ditto. (build_this): Fix calls for SFINAE. (build_user_type_conversion): Ditto. (resolve_args): Ditto. (build_new_function_call): Add SFINAE support. (build_operator_new_call): Fix calls for SFINAE. (build_object_call): Add SFINAE support. (build_conditional_expr): Ditto. (build_new_op): Ditto. (build_op_delete_call): Fix calls for SFINAE. (build_temp): Ditto. (convert_like_real): Add SFINAE support. (build_x_va_arg): Fix calls for SFINAE. (convert_default_arg): Ditto. (build_over_call): Add SFINAE support. (build_java_interface_fn_ref): Fix calls for SFINAE. (build_special_member_call): Add SFINAE support. (build_new_method_call): Ditto. (perform_implicit_conversion): Ditto. (perform_direct_initialization_if_possible): Ditto. (initialize_reference): Fix calls for SFINAE. * method.c (do_build_assign_ref): Fix calls for SFINAE. * rtti.c (build_headof): Fix calls for SFINAE. (get_tinfo_decl_dynamic): Ditto. (get_typeid): Ditto. (build_dynamic_cast_1): Add SFINAE support. (build_dynamic_cast): Ditto. (tinfo_base_init): Fix calls for SFINAE. * except.c (do_get_exception_ptr): Fix calls for SFINAE. (do_end_catch): Ditto. (initialize_handler_parm): Ditto. (expand_start_catch_block): Ditto. (do_allocate_exception): Ditto. (do_free_exception): Ditto. (build_throw): Ditto. * cvt.c (build_up_reference): Fix calls for SFINAE. (convert_to_reference): Ditto. (ocp_convert): Ditto. (convert_to_void): Add SFINAE support. * tree.c (build_dummy_object): Fix calls for SFINAE. (stabilize_expr): Ditto. * cp-tree.h (build_conditional_expr): Add tsubst_flags_t parameter. (build_new_method_call): Ditto. (build_special_member_call): Ditto. (build_new_op): Ditto. (perform_implicit_conversion): Ditto. (perform_direct_initialization_if_possible): Ditto. (convert_to_void): Ditto. (build_aggr_init): Ditto. (build_new): Ditto. (build_vec_init): Ditto. (build_dynamic_cast): Ditto. (finish_call_expr): Ditto (cxx_sizeof_or_alignof_expr): Add COMPLAIN parameter. (cxx_sizeof_nowarn): Remove macro; add function declaration. (build_class_member_access_expr): Add tsubst_flags_t parameter. (finish_class_member_access_expr): Ditto. (build_x_indirect_ref): Ditto. (cp_build_indirect_ref): New. (cp_build_function_call): Add tsubst_flags_t parameter. (build_x_unary_op): Ditto. (cp_build_unary_op): New. (build_x_conditional_expr): Add tsubst_flags_t parameter. (build_x_compound_expr): Ditto. (build_compound_expr): Ditto. (build_static_cast): Ditto. (build_reinterpret_cast): Ditto. (build_const_cast): Ditto. (build_c_cast): Ditto. (build_x_modify_expr): Ditto. (cp_build_modify_expr): New. (convert_for_initialization): Add tsubst_flags_t parameter. (cp_build_binary_op): Remove macro; add function declaration. (invalid_nonstatic_memfn_p): Add tsubst_flags_t parameter. (lvalue_or_else): Ditto. (build_functional_cast): Ditto. * typeck2.c (digest_init): Fix calls for SFINAE. (process_init_constructor_array): Ditto. (process_init_constructor_record): Ditto. (build_x_arrow): Ditto. (build_m_component_ref): Ditto. (build_functional_cast): Add SFINAE support. * pt.c (tsubst_copy_and_build): Add (more) SFINAE support. * semantics.c (simplify_loop_decl_cond): Fix calls for SFINAE. (finish_expr_stmt): Ditto. (finish_for_expr): Ditto. (finish_asm_stmt): Ditto. (finish_non_static_data_member): Ditto. (finish_qualified_id_expr): Ditto. (finish_call_expr): Add SFINAE support. (finish_increment_expr): Fix calls for SFINAE. (finish_unary_op_expr): Ditto. (simplify_aggr_init_expr): Ditto. (finish_omp_clauses): Ditto. (finish_omp_for): Ditto. (finish_omp_barrier): Ditto. (finish_omo_flush): Ditto. * decl2.c (grok_array_decl): Fix calls or SFINAE. (build_anon_union_vars): Ditto. (get_guard_cond): Ditto. (set_guard): Ditto. (one_static_initialization_or_destruction): Ditto. (do_static_initialization_or_destruction): Ditto. (generate_ctor_or_dtor_function): Ditto. (build_offset_ref_call_from_tree): Ditto. * parser.c (cp_parser_postfix_expression): Fix calls for SFINAE. (cp_parser_postfix_dot_deref_expression): Ditto. (cp_parser_unary_expression): Ditto. (cp_parser_new_expression): Ditto. (cp_parser_cast_expression): Ditto. (cp_parser_binary_expression): Ditto. (cp_parser_question_colon_clause): Ditto. (cp_parser_assignment_expression): Ditto. (cp_parser_expression): Ditto. (cp_parser_builtin_offsetof): Ditto. (cp_parser_template_argument): Ditto. (cp_parser_functional_cast): Ditto. 2008-03-25 Douglas Gregor * c-common.c (c_sizeof_or_alignof_type): If we're not allowed to complain when we hit an error, return ERROR_MARK_NODE. 2008-03-25 Douglas Gregor * g++.dg/template/sfinae4.C: New. * g++.dg/template/sfinae5.C: New. * g++.dg/template/sfinae6.C: New. * g++.dg/template/sfinae6_neg.C: New. * g++.dg/template/sfinae7.C: New. * g++.dg/template/sfinae8.C: New. * g++.dg/template/sfinae9.C: New. * g++.dg/template/sfinae10.C: New. * g++.dg/template/sfinae11.C: New. * g++.dg/template/sfinae12.C: New. * g++.dg/template/sfinae13.C: New. * g++.dg/template/sfinae14C: New. From-SVN: r133519 --- gcc/ChangeLog | 5 + gcc/c-common.c | 4 + gcc/cp/ChangeLog | 205 +++++ gcc/cp/call.c | 429 +++++---- gcc/cp/class.c | 30 +- gcc/cp/cp-tree.h | 99 +- gcc/cp/cvt.c | 64 +- gcc/cp/decl.c | 25 +- gcc/cp/decl2.c | 47 +- gcc/cp/except.c | 36 +- gcc/cp/init.c | 260 ++++-- gcc/cp/method.c | 6 +- gcc/cp/parser.c | 60 +- gcc/cp/pt.c | 60 +- gcc/cp/rtti.c | 44 +- gcc/cp/semantics.c | 58 +- gcc/cp/tree.c | 6 +- gcc/cp/typeck.c | 947 +++++++++++++------- gcc/cp/typeck2.c | 27 +- gcc/testsuite/ChangeLog | 15 + gcc/testsuite/g++.dg/template/sfinae10.C | 181 ++++ gcc/testsuite/g++.dg/template/sfinae11.C | 53 ++ gcc/testsuite/g++.dg/template/sfinae12.C | 47 + gcc/testsuite/g++.dg/template/sfinae13.C | 86 ++ gcc/testsuite/g++.dg/template/sfinae14.C | 79 ++ gcc/testsuite/g++.dg/template/sfinae4.C | 35 + gcc/testsuite/g++.dg/template/sfinae5.C | 47 + gcc/testsuite/g++.dg/template/sfinae6.C | 83 ++ gcc/testsuite/g++.dg/template/sfinae6_neg.C | 58 ++ gcc/testsuite/g++.dg/template/sfinae7.C | 199 ++++ gcc/testsuite/g++.dg/template/sfinae8.C | 182 ++++ gcc/testsuite/g++.dg/template/sfinae9.C | 207 +++++ 32 files changed, 2876 insertions(+), 808 deletions(-) create mode 100644 gcc/testsuite/g++.dg/template/sfinae10.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae11.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae12.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae13.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae14.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae4.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae5.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae6.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae6_neg.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae7.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae8.C create mode 100644 gcc/testsuite/g++.dg/template/sfinae9.C diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 03f6332e777..05ece074638 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,8 @@ +2008-03-25 Douglas Gregor + + * c-common.c (c_sizeof_or_alignof_type): If we're not allowed to + complain when we hit an error, return ERROR_MARK_NODE. + 2008-03-25 Naveen.H.S * config/sh/constraints.md (Pso, Psz): New constraints. diff --git a/gcc/c-common.c b/gcc/c-common.c index 2bc74348e6a..1b629745239 100644 --- a/gcc/c-common.c +++ b/gcc/c-common.c @@ -3347,6 +3347,8 @@ c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain) { if (complain && (pedantic || warn_pointer_arith)) pedwarn ("invalid application of % to a function type"); + else if (!complain) + return error_mark_node; value = size_one_node; } else @@ -3357,6 +3359,8 @@ c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain) if (type_code == VOID_TYPE && complain && (pedantic || warn_pointer_arith)) pedwarn ("invalid application of %qs to a void type", op_name); + else if (!complain) + return error_mark_node; value = size_one_node; } else if (!COMPLETE_TYPE_P (type)) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index ce147f76da1..c90f58396bd 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,208 @@ +2008-03-25 Douglas Gregor + + * typeck.c (composite_pointer_type_r): Add SFINAE support. + (composite_pointer_type): Ditto. + (common_type): Fix call to composite_pointer_type. + (cxx_sizeof_nowarn): New; used to be a macro. + (cxx_sizeof_expr): Add SFINAE support. + (cxx_alignof_expr): Ditto. + (decay_conversion): Fix calls for SFINAE support. + (rationalize_conditional_expr): Add SFINAE support. + (build_class_member_access_expr): Ditto. + (finish_class_member_access_expr): Ditto. + (build_x_indirect_ref): Ditto. + (build_indirect_ref): Original version renamed to + cp_build_indirect_ref; new version provides a bridge from + c-common. + (cp_build_indirect_ref): Was build_indirect_ref; added SFINAE + support. + (get_member_function_from_ptrfunc): Fix calls for SFINAE support. + (build_function_call): Original version renamed to + cp_build_function_call; new version provides a bridge from + c-common. + (cp_build_function_call): Was build_function_call; added SFINAE + support. + (convert_arguments): Add SFINAE support. + (build_x_binary_op): Ditto. + (build_binary_op): Original version renamed to cp_build_binary_op; + new version provides a bridge from c-common. + (cp_build_binary_op): Was build_binary_op; added SFINAE support. + (pointer_diff): Fix calls for SFINAE. + (build_x_unary_op): Add SFINAE support. + (condition_conversion): Fix calls for SFINAE. + (build_unary_op): Original version renamed to cp_build_unary_op; + new version provides a bridge from c-common. + (cp_build_unary_op): Was build_unary_op; added SFINAE support. + (unary_complex_lvalue): Fix calls for SFINAE. + (build_x_conditional_expr): Add SFINAE support. + (build_x_compound_expr_from_list): Fix calls for SFINAE. + (build_x_compound_expr): Add SFINAE support. + (convert_ptrmem): Fix calls for SFINAE. + (build_static_cast_1): Add SFINAE support. + (build_static_cast): Ditto. + (build_reinterpret_cast_1): Ditto. + (build_reinterpret_cast): Ditto. + (build_const_cast_1): Ditto. + (build_const_cast): Ditto. + (build_c_cast): Ditto. + (build_modify_expr): Original version renamed to + cp_build_modify_expr; new version provides a bridge from c-common. + (cp_build_modify_expr): Was build_modify_expr; added SFINAE + support. + (build_x_modify_expr): Add SFINAE support. + (build_ptrmemfunc): Fix calls for SFINAE. + (convert_for_assignment): Add SFINAE support. + (convert_for_initialization): Ditto. + (check_return_expr): Fix calls for SFINAE. + (lvalue_or_else): Add SFINAE support. + * init.c (perform_member_init): Fix calls for SFINAE. + (emit_mem_initializers): Ditto. + (expand_virtual_init): Ditto. + (expand_cleanup_for_base): Ditto. + (build_aggr_init): Add SFINAE support. + (expand_default_init): Ditto. + (expand_aggr_init_1): Fix calls for SFINAE. + (build_offset_ref): Ditto. + (build_new_1): Add SFINAE support. + (build_new): Ditto. + (build_vec_delete_1): Fix calls for SFINAE. + (get_temp_regvar): Ditto. + (build_vec_init): Add SFINAE support. + (build_dtor_call): Fix calls for SFINAE. + (build_delete): Ditto. + (push_base_cleanups): Ditto. + (build_vec_delete_1): Ditto. + * class.c (build_base_path): Fix calls for SFINAE. + (build_simple_base_path): Ditto. + (convert_to_base_statically): Ditto. + (build_vfn_ref): Ditto. + (resolve_address_of_overloaded_function): Ditto. + * decl.c (check_initializer): Fix calls for SFINAE. + (register_dtor_fn): Ditto. + (compute_array_index_type): Ditto. + (finish_enum): Ditto. + (start_preparsed_function): Ditto. + (cxx_maybe_build_cleanup): Ditto. + * call.c (convert_like): Add COMPLAIN argument. + (convert_like_with_context): Ditto. + (build_this): Fix calls for SFINAE. + (build_user_type_conversion): Ditto. + (resolve_args): Ditto. + (build_new_function_call): Add SFINAE support. + (build_operator_new_call): Fix calls for SFINAE. + (build_object_call): Add SFINAE support. + (build_conditional_expr): Ditto. + (build_new_op): Ditto. + (build_op_delete_call): Fix calls for SFINAE. + (build_temp): Ditto. + (convert_like_real): Add SFINAE support. + (build_x_va_arg): Fix calls for SFINAE. + (convert_default_arg): Ditto. + (build_over_call): Add SFINAE support. + (build_java_interface_fn_ref): Fix calls for SFINAE. + (build_special_member_call): Add SFINAE support. + (build_new_method_call): Ditto. + (perform_implicit_conversion): Ditto. + (perform_direct_initialization_if_possible): Ditto. + (initialize_reference): Fix calls for SFINAE. + * method.c (do_build_assign_ref): Fix calls for SFINAE. + * rtti.c (build_headof): Fix calls for SFINAE. + (get_tinfo_decl_dynamic): Ditto. + (get_typeid): Ditto. + (build_dynamic_cast_1): Add SFINAE support. + (build_dynamic_cast): Ditto. + (tinfo_base_init): Fix calls for SFINAE. + * except.c (do_get_exception_ptr): Fix calls for SFINAE. + (do_end_catch): Ditto. + (initialize_handler_parm): Ditto. + (expand_start_catch_block): Ditto. + (do_allocate_exception): Ditto. + (do_free_exception): Ditto. + (build_throw): Ditto. + * cvt.c (build_up_reference): Fix calls for SFINAE. + (convert_to_reference): Ditto. + (ocp_convert): Ditto. + (convert_to_void): Add SFINAE support. + * tree.c (build_dummy_object): Fix calls for SFINAE. + (stabilize_expr): Ditto. + * cp-tree.h (build_conditional_expr): Add tsubst_flags_t + parameter. + (build_new_method_call): Ditto. + (build_special_member_call): Ditto. + (build_new_op): Ditto. + (perform_implicit_conversion): Ditto. + (perform_direct_initialization_if_possible): Ditto. + (convert_to_void): Ditto. + (build_aggr_init): Ditto. + (build_new): Ditto. + (build_vec_init): Ditto. + (build_dynamic_cast): Ditto. + (finish_call_expr): Ditto + (cxx_sizeof_or_alignof_expr): Add COMPLAIN parameter. + (cxx_sizeof_nowarn): Remove macro; add function declaration. + (build_class_member_access_expr): Add tsubst_flags_t parameter. + (finish_class_member_access_expr): Ditto. + (build_x_indirect_ref): Ditto. + (cp_build_indirect_ref): New. + (cp_build_function_call): Add tsubst_flags_t parameter. + (build_x_unary_op): Ditto. + (cp_build_unary_op): New. + (build_x_conditional_expr): Add tsubst_flags_t parameter. + (build_x_compound_expr): Ditto. + (build_compound_expr): Ditto. + (build_static_cast): Ditto. + (build_reinterpret_cast): Ditto. + (build_const_cast): Ditto. + (build_c_cast): Ditto. + (build_x_modify_expr): Ditto. + (cp_build_modify_expr): New. + (convert_for_initialization): Add tsubst_flags_t parameter. + (cp_build_binary_op): Remove macro; add function declaration. + (invalid_nonstatic_memfn_p): Add tsubst_flags_t parameter. + (lvalue_or_else): Ditto. + (build_functional_cast): Ditto. + * typeck2.c (digest_init): Fix calls for SFINAE. + (process_init_constructor_array): Ditto. + (process_init_constructor_record): Ditto. + (build_x_arrow): Ditto. + (build_m_component_ref): Ditto. + (build_functional_cast): Add SFINAE support. + * pt.c (tsubst_copy_and_build): Add (more) SFINAE support. + * semantics.c (simplify_loop_decl_cond): Fix calls for SFINAE. + (finish_expr_stmt): Ditto. + (finish_for_expr): Ditto. + (finish_asm_stmt): Ditto. + (finish_non_static_data_member): Ditto. + (finish_qualified_id_expr): Ditto. + (finish_call_expr): Add SFINAE support. + (finish_increment_expr): Fix calls for SFINAE. + (finish_unary_op_expr): Ditto. + (simplify_aggr_init_expr): Ditto. + (finish_omp_clauses): Ditto. + (finish_omp_for): Ditto. + (finish_omp_barrier): Ditto. + (finish_omo_flush): Ditto. + * decl2.c (grok_array_decl): Fix calls or SFINAE. + (build_anon_union_vars): Ditto. + (get_guard_cond): Ditto. + (set_guard): Ditto. + (one_static_initialization_or_destruction): Ditto. + (do_static_initialization_or_destruction): Ditto. + (generate_ctor_or_dtor_function): Ditto. + (build_offset_ref_call_from_tree): Ditto. + * parser.c (cp_parser_postfix_expression): Fix calls for SFINAE. + (cp_parser_postfix_dot_deref_expression): Ditto. + (cp_parser_unary_expression): Ditto. + (cp_parser_new_expression): Ditto. + (cp_parser_cast_expression): Ditto. + (cp_parser_binary_expression): Ditto. + (cp_parser_question_colon_clause): Ditto. + (cp_parser_assignment_expression): Ditto. + (cp_parser_expression): Ditto. + (cp_parser_builtin_offsetof): Ditto. + (cp_parser_template_argument): Ditto. + (cp_parser_functional_cast): Ditto. + 2008-03-24 Tom Tromey * lex.c (handle_pragma_interface): Don't copy the filename. diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 41e6933f686..29dda07426f 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -126,21 +126,21 @@ static struct z_candidate * tourney (struct z_candidate *); static int equal_functions (tree, tree); static int joust (struct z_candidate *, struct z_candidate *, bool); static int compare_ics (conversion *, conversion *); -static tree build_over_call (struct z_candidate *, int); +static tree build_over_call (struct z_candidate *, int, tsubst_flags_t); static tree build_java_interface_fn_ref (tree, tree); -#define convert_like(CONV, EXPR) \ +#define convert_like(CONV, EXPR, COMPLAIN) \ convert_like_real ((CONV), (EXPR), NULL_TREE, 0, 0, \ /*issue_conversion_warnings=*/true, \ - /*c_cast_p=*/false) -#define convert_like_with_context(CONV, EXPR, FN, ARGNO) \ - convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \ - /*issue_conversion_warnings=*/true, \ - /*c_cast_p=*/false) + /*c_cast_p=*/false, (COMPLAIN)) +#define convert_like_with_context(CONV, EXPR, FN, ARGNO, COMPLAIN ) \ + convert_like_real ((CONV), (EXPR), (FN), (ARGNO), 0, \ + /*issue_conversion_warnings=*/true, \ + /*c_cast_p=*/false, (COMPLAIN)) static tree convert_like_real (conversion *, tree, tree, int, int, bool, - bool); + bool, tsubst_flags_t); static void op_error (enum tree_code, enum tree_code, tree, tree, tree, const char *); -static tree build_object_call (tree, tree); +static tree build_object_call (tree, tree, tsubst_flags_t); static tree resolve_args (tree); static struct z_candidate *build_user_type_conversion_1 (tree, tree, int); static void print_z_candidate (const char *, struct z_candidate *); @@ -2418,7 +2418,7 @@ build_this (tree obj) if (processing_template_decl) return build_address (obj); - return build_unary_op (ADDR_EXPR, obj, 0); + return cp_build_unary_op (ADDR_EXPR, obj, 0, tf_warning_or_error); } /* Returns true iff functions are equivalent. Equivalent functions are @@ -2750,7 +2750,7 @@ build_user_type_conversion (tree totype, tree expr, int flags) { if (cand->second_conv->kind == ck_ambig) return error_mark_node; - expr = convert_like (cand->second_conv, expr); + expr = convert_like (cand->second_conv, expr, tf_warning_or_error); return convert_from_reference (expr); } return NULL_TREE; @@ -2773,7 +2773,7 @@ resolve_args (tree args) error ("invalid use of void expression"); return error_mark_node; } - else if (invalid_nonstatic_memfn_p (arg)) + else if (invalid_nonstatic_memfn_p (arg, tf_warning_or_error)) return error_mark_node; } return args; @@ -2837,7 +2837,8 @@ perform_overload_resolution (tree fn, or a static member function) with the ARGS. */ tree -build_new_function_call (tree fn, tree args, bool koenig_p) +build_new_function_call (tree fn, tree args, bool koenig_p, + tsubst_flags_t complain) { struct z_candidate *candidates, *cand; bool any_viable_p; @@ -2858,8 +2859,9 @@ build_new_function_call (tree fn, tree args, bool koenig_p) fn = remove_hidden_names (fn); if (!fn) { - error ("no matching function for call to %<%D(%A)%>", - DECL_NAME (OVL_CURRENT (orig_fn)), args); + if (complain & tf_error) + error ("no matching function for call to %<%D(%A)%>", + DECL_NAME (OVL_CURRENT (orig_fn)), args); return error_mark_node; } } @@ -2871,22 +2873,25 @@ build_new_function_call (tree fn, tree args, bool koenig_p) if (!cand) { - if (!any_viable_p && candidates && ! candidates->next) - return build_function_call (candidates->fn, args); - if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) - fn = TREE_OPERAND (fn, 0); - if (!any_viable_p) - error ("no matching function for call to %<%D(%A)%>", - DECL_NAME (OVL_CURRENT (fn)), args); - else - error ("call of overloaded %<%D(%A)%> is ambiguous", - DECL_NAME (OVL_CURRENT (fn)), args); - if (candidates) - print_z_candidates (candidates); + if (complain & tf_error) + { + if (!any_viable_p && candidates && ! candidates->next) + return cp_build_function_call (candidates->fn, args, complain); + if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) + fn = TREE_OPERAND (fn, 0); + if (!any_viable_p) + error ("no matching function for call to %<%D(%A)%>", + DECL_NAME (OVL_CURRENT (fn)), args); + else + error ("call of overloaded %<%D(%A)%> is ambiguous", + DECL_NAME (OVL_CURRENT (fn)), args); + if (candidates) + print_z_candidates (candidates); + } result = error_mark_node; } else - result = build_over_call (cand, LOOKUP_NORMAL); + result = build_over_call (cand, LOOKUP_NORMAL, complain); /* Free all the conversions we allocated. */ obstack_free (&conversion_obstack, p); @@ -2997,11 +3002,11 @@ build_operator_new_call (tree fnname, tree args, *fn = cand->fn; /* Build the CALL_EXPR. */ - return build_over_call (cand, LOOKUP_NORMAL); + return build_over_call (cand, LOOKUP_NORMAL, tf_warning_or_error); } static tree -build_object_call (tree obj, tree args) +build_object_call (tree obj, tree args, tsubst_flags_t complain) { struct z_candidate *candidates = 0, *cand; tree fns, convs, mem_args = NULL_TREE; @@ -3012,9 +3017,10 @@ build_object_call (tree obj, tree args) if (TYPE_PTRMEMFUNC_P (type)) { - /* It's no good looking for an overloaded operator() on a - pointer-to-member-function. */ - error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj); + if (complain & tf_error) + /* It's no good looking for an overloaded operator() on a + pointer-to-member-function. */ + error ("pointer-to-member function %E cannot be called without an object; consider using .* or ->*", obj); return error_mark_node; } @@ -3088,8 +3094,11 @@ build_object_call (tree obj, tree args) candidates = splice_viable (candidates, pedantic, &any_viable_p); if (!any_viable_p) { - error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args); - print_z_candidates (candidates); + if (complain & tf_error) + { + error ("no match for call to %<(%T) (%A)%>", TREE_TYPE (obj), args); + print_z_candidates (candidates); + } result = error_mark_node; } else @@ -3097,8 +3106,12 @@ build_object_call (tree obj, tree args) cand = tourney (candidates); if (cand == 0) { - error ("call of %<(%T) (%A)%> is ambiguous", TREE_TYPE (obj), args); - print_z_candidates (candidates); + if (complain & tf_error) + { + error ("call of %<(%T) (%A)%> is ambiguous", + TREE_TYPE (obj), args); + print_z_candidates (candidates); + } result = error_mark_node; } /* Since cand->fn will be a type, not a function, for a conversion @@ -3106,12 +3119,13 @@ build_object_call (tree obj, tree args) DECL_NAME here. */ else if (TREE_CODE (cand->fn) == FUNCTION_DECL && DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR) - result = build_over_call (cand, LOOKUP_NORMAL); + result = build_over_call (cand, LOOKUP_NORMAL, complain); else { - obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1); + obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1, + complain); obj = convert_from_reference (obj); - result = build_function_call (obj, args); + result = cp_build_function_call (obj, args, complain); } } @@ -3232,7 +3246,8 @@ conditional_conversion (tree e1, tree e2) arguments to the conditional expression. */ tree -build_conditional_expr (tree arg1, tree arg2, tree arg3) +build_conditional_expr (tree arg1, tree arg2, tree arg3, + tsubst_flags_t complain) { tree arg2_type; tree arg3_type; @@ -3249,7 +3264,7 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3) calculated only once. */ if (!arg2) { - if (pedantic) + if (pedantic && (complain & tf_error)) pedwarn ("ISO C++ forbids omitting the middle term of a ?: expression"); /* Make sure that lvalues remain lvalues. See g++.oliva/ext1.C. */ @@ -3263,7 +3278,7 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3) The first expr ession is implicitly converted to bool (clause _conv_). */ - arg1 = perform_implicit_conversion (boolean_type_node, arg1); + arg1 = perform_implicit_conversion (boolean_type_node, arg1, complain); /* If something has already gone wrong, just pass that fact up the tree. */ @@ -3327,16 +3342,19 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3) result_type = void_type_node; else { - if (VOID_TYPE_P (arg2_type)) - error ("second operand to the conditional operator " - "is of type %, " - "but the third operand is neither a throw-expression " - "nor of type %"); - else - error ("third operand to the conditional operator " - "is of type %, " - "but the second operand is neither a throw-expression " - "nor of type %"); + if (complain & tf_error) + { + if (VOID_TYPE_P (arg2_type)) + error ("second operand to the conditional operator " + "is of type %, " + "but the third operand is neither a throw-expression " + "nor of type %"); + else + error ("third operand to the conditional operator " + "is of type %, " + "but the second operand is neither a throw-expression " + "nor of type %"); + } return error_mark_node; } @@ -3380,7 +3398,7 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3) } else if (conv2 && (!conv2->bad_p || !conv3)) { - arg2 = convert_like (conv2, arg2); + arg2 = convert_like (conv2, arg2, complain); arg2 = convert_from_reference (arg2); arg2_type = TREE_TYPE (arg2); /* Even if CONV2 is a valid conversion, the result of the @@ -3393,7 +3411,7 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3) } else if (conv3 && (!conv3->bad_p || !conv2)) { - arg3 = convert_like (conv3, arg3); + arg3 = convert_like (conv3, arg3, complain); arg3 = convert_from_reference (arg3); arg3_type = TREE_TYPE (arg3); if (error_operand_p (arg3)) @@ -3477,15 +3495,21 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3) candidates = splice_viable (candidates, pedantic, &any_viable_p); if (!any_viable_p) { - op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match"); - print_z_candidates (candidates); + if (complain & tf_error) + { + op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match"); + print_z_candidates (candidates); + } return error_mark_node; } cand = tourney (candidates); if (!cand) { - op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match"); - print_z_candidates (candidates); + if (complain & tf_error) + { + op_error (COND_EXPR, NOP_EXPR, arg1, arg2, arg3, "no match"); + print_z_candidates (candidates); + } return error_mark_node; } @@ -3495,11 +3519,11 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3) the converted operands are used in place of the original operands for the remainder of this section. */ conv = cand->convs[0]; - arg1 = convert_like (conv, arg1); + arg1 = convert_like (conv, arg1, complain); conv = cand->convs[1]; - arg2 = convert_like (conv, arg2); + arg2 = convert_like (conv, arg2, complain); conv = cand->convs[2]; - arg3 = convert_like (conv, arg3); + arg3 = convert_like (conv, arg3, complain); } /* [expr.cond] @@ -3548,17 +3572,25 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3) if (TREE_CODE (arg2_type) == ENUMERAL_TYPE && TREE_CODE (arg3_type) == ENUMERAL_TYPE) - warning (0, "enumeral mismatch in conditional expression: %qT vs %qT", - arg2_type, arg3_type); + { + if (complain & tf_warning) + warning (0, + "enumeral mismatch in conditional expression: %qT vs %qT", + arg2_type, arg3_type); + } else if (extra_warnings && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE && !same_type_p (arg3_type, type_promotes_to (arg2_type))) || (TREE_CODE (arg3_type) == ENUMERAL_TYPE && !same_type_p (arg2_type, type_promotes_to (arg3_type))))) - warning (0, "enumeral and non-enumeral type in conditional expression"); + { + if (complain & tf_warning) + warning (0, + "enumeral and non-enumeral type in conditional expression"); + } - arg2 = perform_implicit_conversion (result_type, arg2); - arg3 = perform_implicit_conversion (result_type, arg3); + arg2 = perform_implicit_conversion (result_type, arg2, complain); + arg3 = perform_implicit_conversion (result_type, arg3, complain); } /* [expr.cond] @@ -3585,17 +3617,19 @@ build_conditional_expr (tree arg1, tree arg2, tree arg3) || (TYPE_PTRMEMFUNC_P (arg2_type) && TYPE_PTRMEMFUNC_P (arg3_type))) { result_type = composite_pointer_type (arg2_type, arg3_type, arg2, - arg3, "conditional expression"); + arg3, "conditional expression", + complain); if (result_type == error_mark_node) return error_mark_node; - arg2 = perform_implicit_conversion (result_type, arg2); - arg3 = perform_implicit_conversion (result_type, arg3); + arg2 = perform_implicit_conversion (result_type, arg2, complain); + arg3 = perform_implicit_conversion (result_type, arg3, complain); } if (!result_type) { - error ("operands to ?: have different types %qT and %qT", - arg2_type, arg3_type); + if (complain & tf_error) + error ("operands to ?: have different types %qT and %qT", + arg2_type, arg3_type); return error_mark_node; } @@ -3707,7 +3741,7 @@ add_candidates (tree fns, tree args, tree build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, - bool *overloaded_p) + bool *overloaded_p, tsubst_flags_t complain) { struct z_candidate *candidates = 0, *cand; tree arglist, fnname; @@ -3747,7 +3781,7 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, gcc_unreachable (); case CALL_EXPR: - return build_object_call (arg1, arg2); + return build_object_call (arg1, arg2, complain); case TRUTH_ORIF_EXPR: case TRUTH_ANDIF_EXPR: @@ -3856,6 +3890,11 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, { case POSTINCREMENT_EXPR: case POSTDECREMENT_EXPR: + /* Don't try anything fancy if we're not allowed to produce + errors. */ + if (!(complain & tf_error)) + return error_mark_node; + /* Look for an `operator++ (int)'. If they didn't have one, then we fall back to the old way of doing things. */ if (flags & LOOKUP_COMPLAIN) @@ -3868,7 +3907,7 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, else code = PREDECREMENT_EXPR; result = build_new_op (code, flags, arg1, NULL_TREE, NULL_TREE, - overloaded_p); + overloaded_p, complain); break; /* The caller will deal with these. */ @@ -3880,7 +3919,7 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, break; default: - if (flags & LOOKUP_COMPLAIN) + if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error)) { op_error (code, code2, arg1, arg2, arg3, "no match"); print_z_candidates (candidates); @@ -3894,7 +3933,7 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, cand = tourney (candidates); if (cand == 0) { - if (flags & LOOKUP_COMPLAIN) + if ((flags & LOOKUP_COMPLAIN) && (complain & tf_error)) { op_error (code, code2, arg1, arg2, arg3, "ambiguous overload"); print_z_candidates (candidates); @@ -3909,12 +3948,12 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, if (resolve_args (arglist) == error_mark_node) result = error_mark_node; else - result = build_over_call (cand, LOOKUP_NORMAL); + result = build_over_call (cand, LOOKUP_NORMAL, complain); } else { /* Give any warnings we noticed during overload resolution. */ - if (cand->warnings) + if (cand->warnings && (complain & tf_warning)) { struct candidate_warning *w; for (w = cand->warnings; w; w = w->next) @@ -3933,7 +3972,8 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, if (TREE_CODE (TREE_TYPE (arg1)) == ENUMERAL_TYPE && TREE_CODE (TREE_TYPE (arg2)) == ENUMERAL_TYPE && (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) - != TYPE_MAIN_VARIANT (TREE_TYPE (arg2)))) + != TYPE_MAIN_VARIANT (TREE_TYPE (arg2))) + && (complain & tf_warning)) { warning (0, "comparison between %q#T and %q#T", TREE_TYPE (arg1), TREE_TYPE (arg2)); @@ -3950,25 +3990,26 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, conv = cand->convs[0]; if (conv->kind == ck_ref_bind) conv = conv->u.next; - arg1 = convert_like (conv, arg1); + arg1 = convert_like (conv, arg1, complain); if (arg2) { conv = cand->convs[1]; if (conv->kind == ck_ref_bind) conv = conv->u.next; - arg2 = convert_like (conv, arg2); + arg2 = convert_like (conv, arg2, complain); } if (arg3) { conv = cand->convs[2]; if (conv->kind == ck_ref_bind) conv = conv->u.next; - arg3 = convert_like (conv, arg3); + arg3 = convert_like (conv, arg3, complain); } if (!expl_eq_arg1) { - warn_logical_operator (code, arg1, arg2); + if (complain & tf_warning) + warn_logical_operator (code, arg1, arg2); expl_eq_arg1 = true; } } @@ -3986,10 +4027,10 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, switch (code) { case MODIFY_EXPR: - return build_modify_expr (arg1, code2, arg2); + return cp_build_modify_expr (arg1, code2, arg2, complain); case INDIRECT_REF: - return build_indirect_ref (arg1, "unary *"); + return cp_build_indirect_ref (arg1, "unary *", complain); case TRUTH_ANDIF_EXPR: case TRUTH_ORIF_EXPR: @@ -4015,7 +4056,7 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, case BIT_AND_EXPR: case BIT_IOR_EXPR: case BIT_XOR_EXPR: - return cp_build_binary_op (code, arg1, arg2); + return cp_build_binary_op (code, arg1, arg2, complain); case UNARY_PLUS_EXPR: case NEGATE_EXPR: @@ -4027,16 +4068,18 @@ build_new_op (enum tree_code code, int flags, tree arg1, tree arg2, tree arg3, case POSTDECREMENT_EXPR: case REALPART_EXPR: case IMAGPART_EXPR: - return build_unary_op (code, arg1, candidates != 0); + return cp_build_unary_op (code, arg1, candidates != 0, complain); case ARRAY_REF: return build_array_ref (arg1, arg2); case COND_EXPR: - return build_conditional_expr (arg1, arg2, arg3); + return build_conditional_expr (arg1, arg2, arg3, complain); case MEMBER_REF: - return build_m_component_ref (build_indirect_ref (arg1, NULL), arg2); + return build_m_component_ref (cp_build_indirect_ref (arg1, NULL, + complain), + arg2); /* The caller will deal with these. */ case ADDR_EXPR: @@ -4205,7 +4248,7 @@ build_op_delete_call (enum tree_code code, tree addr, tree size, else args = tree_cons (NULL_TREE, addr, build_tree_list (NULL_TREE, size)); - return build_function_call (fn, args); + return cp_build_function_call (fn, args, tf_warning_or_error); } } @@ -4268,7 +4311,7 @@ build_temp (tree expr, tree type, int flags, expr = build_special_member_call (NULL_TREE, complete_ctor_identifier, build_tree_list (NULL_TREE, expr), - type, flags); + type, flags, tf_warning_or_error); if (warningcount > savew) *diagnostic_fn = warning0; else if (errorcount > savee) @@ -4317,7 +4360,7 @@ conversion_null_warnings (tree totype, tree expr, tree fn, int argnum) static tree convert_like_real (conversion *convs, tree expr, tree fn, int argnum, int inner, bool issue_conversion_warnings, - bool c_cast_p) + bool c_cast_p, tsubst_flags_t complain) { tree totype = convs->type; diagnostic_fn_t diagnostic_fn; @@ -4335,23 +4378,31 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, { expr = convert_like_real (t, expr, fn, argnum, 1, /*issue_conversion_warnings=*/false, - /*c_cast_p=*/false); + /*c_cast_p=*/false, + complain); break; } else if (t->kind == ck_ambig) return convert_like_real (t, expr, fn, argnum, 1, /*issue_conversion_warnings=*/false, - /*c_cast_p=*/false); + /*c_cast_p=*/false, + complain); else if (t->kind == ck_identity) break; } - permerror ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype); - if (fn) - permerror (" initializing argument %P of %qD", argnum, fn); + if (complain & tf_error) + { + permerror ("invalid conversion from %qT to %qT", TREE_TYPE (expr), totype); + if (fn) + permerror (" initializing argument %P of %qD", argnum, fn); + } + else + return error_mark_node; + return cp_convert (totype, expr); } - if (issue_conversion_warnings) + if (issue_conversion_warnings && (complain & tf_warning)) conversion_null_warnings (totype, expr, fn, argnum); switch (convs->kind) @@ -4367,7 +4418,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, for (i = 0; i < cand->num_convs; ++i) cand->convs[i]->user_conv_p = true; - expr = build_over_call (cand, LOOKUP_NORMAL); + expr = build_over_call (cand, LOOKUP_NORMAL, complain); /* If this is a constructor or a function returning an aggr type, we need to build up a TARGET_EXPR. */ @@ -4394,7 +4445,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING|LOOKUP_NO_CONVERSION, &diagnostic_fn)); - if (diagnostic_fn) + if (diagnostic_fn && (complain & tf_error)) { if (fn) diagnostic_fn @@ -4410,7 +4461,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, } case ck_identity: if (type_unknown_p (expr)) - expr = instantiate_type (totype, expr, tf_warning_or_error); + expr = instantiate_type (totype, expr, complain); /* Convert a constant to its underlying value, unless we are about to bind it to a reference, in which case we need to leave it as an lvalue. */ @@ -4436,7 +4487,8 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, expr = convert_like_real (convs->u.next, expr, fn, argnum, convs->kind == ck_ref_bind ? -1 : 1, convs->kind == ck_ref_bind ? issue_conversion_warnings : false, - c_cast_p); + c_cast_p, + complain); if (expr == error_mark_node) return error_mark_node; @@ -4453,10 +4505,10 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, /* We are going to bind a reference directly to a base-class subobject of EXPR. */ /* Build an expression for `*((base*) &expr)'. */ - expr = build_unary_op (ADDR_EXPR, expr, 0); + expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain); expr = convert_to_base (expr, build_pointer_type (totype), !c_cast_p, /*nonnull=*/true); - expr = build_indirect_ref (expr, "implicit conversion"); + expr = cp_build_indirect_ref (expr, "implicit conversion", complain); return expr; } @@ -4470,7 +4522,12 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, flags |= LOOKUP_NO_CONVERSION; expr = build_temp (expr, totype, flags, &diagnostic_fn); if (diagnostic_fn && fn) - diagnostic_fn (" initializing argument %P of %qD", argnum, fn); + { + if ((complain & tf_error)) + diagnostic_fn (" initializing argument %P of %qD", argnum, fn); + else if (diagnostic_fn == error) + return error_mark_node; + } return build_cplus_new (totype, expr); case ck_ref_bind: @@ -4482,7 +4539,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, VA_ARG_EXPR and CONSTRUCTOR expressions are special cases that need temporaries, even when their types are reference compatible with the type of reference being bound, so the - upcoming call to build_unary_op (ADDR_EXPR, expr, ...) + upcoming call to cp_build_unary_op (ADDR_EXPR, expr, ...) doesn't fail. */ if (convs->need_temporary_p || TREE_CODE (expr) == CONSTRUCTOR @@ -4494,16 +4551,19 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, if (!CP_TYPE_CONST_NON_VOLATILE_P (TREE_TYPE (ref_type)) && !TYPE_REF_IS_RVALUE (ref_type)) { - /* If the reference is volatile or non-const, we - cannot create a temporary. */ - if (lvalue & clk_bitfield) - error ("cannot bind bitfield %qE to %qT", - expr, ref_type); - else if (lvalue & clk_packed) - error ("cannot bind packed field %qE to %qT", - expr, ref_type); - else - error ("cannot bind rvalue %qE to %qT", expr, ref_type); + if (complain & tf_error) + { + /* If the reference is volatile or non-const, we + cannot create a temporary. */ + if (lvalue & clk_bitfield) + error ("cannot bind bitfield %qE to %qT", + expr, ref_type); + else if (lvalue & clk_packed) + error ("cannot bind packed field %qE to %qT", + expr, ref_type); + else + error ("cannot bind rvalue %qE to %qT", expr, ref_type); + } return error_mark_node; } /* If the source is a packed field, and we must use a copy @@ -4516,8 +4576,9 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, && CLASS_TYPE_P (type) && !TYPE_HAS_TRIVIAL_INIT_REF (type)) { - error ("cannot bind packed field %qE to %qT", - expr, ref_type); + if (complain & tf_error) + error ("cannot bind packed field %qE to %qT", + expr, ref_type); return error_mark_node; } if (lvalue & clk_bitfield) @@ -4527,7 +4588,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum, /* Take the address of the thing to which we will bind the reference. */ - expr = build_unary_op (ADDR_EXPR, expr, 1); + expr = cp_build_unary_op (ADDR_EXPR, expr, 1, complain); if (expr == error_mark_node) return error_mark_node; @@ -4652,7 +4713,7 @@ build_x_va_arg (tree expr, tree type) expr = convert (build_pointer_type (type1), null_node); expr = build2 (COMPOUND_EXPR, TREE_TYPE (expr), call_builtin_trap (), expr); - expr = build_indirect_ref (expr, NULL); + expr = cp_build_indirect_ref (expr, NULL, tf_warning_or_error); return expr; } @@ -4719,7 +4780,8 @@ convert_default_arg (tree type, tree arg, tree fn, int parmnum) { arg = digest_init (type, arg); arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL, - "default argument", fn, parmnum); + "default argument", fn, parmnum, + tf_warning_or_error); } else { @@ -4732,7 +4794,8 @@ convert_default_arg (tree type, tree arg, tree fn, int parmnum) if (!CONSTANT_CLASS_P (arg)) arg = unshare_expr (arg); arg = convert_for_initialization (0, type, arg, LOOKUP_NORMAL, - "default argument", fn, parmnum); + "default argument", fn, parmnum, + tf_warning_or_error); arg = convert_for_arg_passing (type, arg); } @@ -4845,7 +4908,7 @@ magic_varargs_p (tree fn) bitmask of various LOOKUP_* flags which apply to the call itself. */ static tree -build_over_call (struct z_candidate *cand, int flags) +build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain) { tree fn = cand->fn; tree args = cand->args; @@ -4957,8 +5020,13 @@ build_over_call (struct z_candidate *cand, int flags) tree base_binfo; if (convs[i]->bad_p) - permerror ("passing %qT as % argument of %q#D discards qualifiers", - TREE_TYPE (argtype), fn); + { + if (complain & tf_error) + permerror ("passing %qT as % argument of %q#D discards qualifiers", + TREE_TYPE (argtype), fn); + else + return error_mark_node; + } /* [class.mfct.nonstatic]: If a nonstatic member function of a class X is called for an object that is not of type X, or of a type @@ -5008,10 +5076,13 @@ build_over_call (struct z_candidate *cand, int flags) conv = conv->u.next; val = convert_like_with_context - (conv, TREE_VALUE (arg), fn, i - is_method); + (conv, TREE_VALUE (arg), fn, i - is_method, complain); val = convert_for_arg_passing (type, val); - argarray[j++] = val; + if ((complain == tf_none) && val == error_mark_node) + return error_mark_node; + else + argarray[j++] = val; } /* Default arguments */ @@ -5067,7 +5138,7 @@ build_over_call (struct z_candidate *cand, int flags) if (targ) arg = targ; else - arg = build_indirect_ref (arg, 0); + arg = cp_build_indirect_ref (arg, 0, complain); /* [class.copy]: the copy constructor is implicitly defined even if the implementation elided its use. */ @@ -5091,7 +5162,7 @@ build_over_call (struct z_candidate *cand, int flags) && !move_fn_p (fn))) { tree to = stabilize_reference - (build_indirect_ref (TREE_VALUE (args), 0)); + (cp_build_indirect_ref (TREE_VALUE (args), 0, complain)); val = build2 (INIT_EXPR, DECL_CONTEXT (fn), to, arg); return val; @@ -5102,14 +5173,14 @@ build_over_call (struct z_candidate *cand, int flags) && TYPE_HAS_TRIVIAL_ASSIGN_REF (DECL_CONTEXT (fn))) { tree to = stabilize_reference - (build_indirect_ref (argarray[0], 0)); + (cp_build_indirect_ref (argarray[0], 0, complain)); tree type = TREE_TYPE (to); tree as_base = CLASSTYPE_AS_BASE (type); arg = argarray[1]; if (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (as_base))) { - arg = build_indirect_ref (arg, 0); + arg = cp_build_indirect_ref (arg, 0, complain); val = build2 (MODIFY_EXPR, TREE_TYPE (to), to, arg); } else @@ -5121,12 +5192,12 @@ build_over_call (struct z_candidate *cand, int flags) arg2 = TYPE_SIZE_UNIT (as_base); arg1 = arg; - arg0 = build_unary_op (ADDR_EXPR, to, 0); + arg0 = cp_build_unary_op (ADDR_EXPR, to, 0, complain); t = implicit_built_in_decls[BUILT_IN_MEMCPY]; t = build_call_n (t, 3, arg0, arg1, arg2); t = convert (TREE_TYPE (arg0), t); - val = build_indirect_ref (t, 0); + val = cp_build_indirect_ref (t, 0, complain); } return val; @@ -5227,7 +5298,8 @@ build_java_interface_fn_ref (tree fn, tree instance) /* Look up the pointer to the runtime java.lang.Class object for `instance'. This is the first entry in the vtable. */ - klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0), + klass_ref = build_vtbl_ref (cp_build_indirect_ref (instance, 0, + tf_warning_or_error), integer_zero_node); /* Get the java.lang.Class pointer for the interface being called. */ @@ -5300,7 +5372,7 @@ in_charge_arg_for_name (tree name) tree build_special_member_call (tree instance, tree name, tree args, - tree binfo, int flags) + tree binfo, int flags, tsubst_flags_t complain) { tree fns; /* The type of the subobject to be constructed or destroyed. */ @@ -5390,7 +5462,8 @@ build_special_member_call (tree instance, tree name, tree args, return build_new_method_call (instance, fns, args, TYPE_BINFO (BINFO_TYPE (binfo)), - flags, /*fn=*/NULL); + flags, /*fn=*/NULL, + complain); } /* Return the NAME, as a C string. The NAME indicates a function that @@ -5444,7 +5517,7 @@ name_as_c_string (tree name, tree type, bool *free_p) tree build_new_method_call (tree instance, tree fns, tree args, tree conversion_path, int flags, - tree *fn_p) + tree *fn_p, tsubst_flags_t complain) { struct z_candidate *candidates = 0, *cand; tree explicit_targs = NULL_TREE; @@ -5477,7 +5550,8 @@ build_new_method_call (tree instance, tree fns, tree args, if (!BASELINK_P (fns)) { - error ("call to non-function %qD", fns); + if (complain & tf_error) + error ("call to non-function %qD", fns); return error_mark_node; } @@ -5594,21 +5668,24 @@ build_new_method_call (tree instance, tree fns, tree args, candidates = splice_viable (candidates, pedantic, &any_viable_p); if (!any_viable_p) { - if (!COMPLETE_TYPE_P (basetype)) - cxx_incomplete_type_error (instance_ptr, basetype); - else + if (complain & tf_error) { - char *pretty_name; - bool free_p; + if (!COMPLETE_TYPE_P (basetype)) + cxx_incomplete_type_error (instance_ptr, basetype); + else + { + char *pretty_name; + bool free_p; - pretty_name = name_as_c_string (name, basetype, &free_p); - error ("no matching function for call to %<%T::%s(%A)%#V%>", - basetype, pretty_name, user_args, - TREE_TYPE (TREE_TYPE (instance_ptr))); - if (free_p) - free (pretty_name); + pretty_name = name_as_c_string (name, basetype, &free_p); + error ("no matching function for call to %<%T::%s(%A)%#V%>", + basetype, pretty_name, user_args, + TREE_TYPE (TREE_TYPE (instance_ptr))); + if (free_p) + free (pretty_name); + } + print_z_candidates (candidates); } - print_z_candidates (candidates); call = error_mark_node; } else @@ -5619,12 +5696,15 @@ build_new_method_call (tree instance, tree fns, tree args, char *pretty_name; bool free_p; - pretty_name = name_as_c_string (name, basetype, &free_p); - error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name, - user_args); - print_z_candidates (candidates); - if (free_p) - free (pretty_name); + if (complain & tf_error) + { + pretty_name = name_as_c_string (name, basetype, &free_p); + error ("call of overloaded %<%s(%A)%> is ambiguous", pretty_name, + user_args); + print_z_candidates (candidates); + if (free_p) + free (pretty_name); + } call = error_mark_node; } else @@ -5635,7 +5715,8 @@ build_new_method_call (tree instance, tree fns, tree args, && DECL_PURE_VIRTUAL_P (fn) && instance == current_class_ref && (DECL_CONSTRUCTOR_P (current_function_decl) - || DECL_DESTRUCTOR_P (current_function_decl))) + || DECL_DESTRUCTOR_P (current_function_decl)) + && (complain & tf_warning)) /* This is not an error, it is runtime undefined behavior. */ warning (0, (DECL_CONSTRUCTOR_P (current_function_decl) ? @@ -5646,8 +5727,9 @@ build_new_method_call (tree instance, tree fns, tree args, if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE && is_dummy_object (instance_ptr)) { - error ("cannot call member function %qD without object", - fn); + if (complain & tf_error) + error ("cannot call member function %qD without object", + fn); call = error_mark_node; } else @@ -5659,7 +5741,7 @@ build_new_method_call (tree instance, tree fns, tree args, if (fn_p) *fn_p = fn; /* Build the actual CALL_EXPR. */ - call = build_over_call (cand, flags); + call = build_over_call (cand, flags, complain); /* In an expression of the form `a->f()' where `f' turns out to be a static member function, `a' is none-the-less evaluated. */ @@ -6608,7 +6690,7 @@ can_convert_arg_bad (tree to, tree from, tree arg) doing a bad conversion, convert_like will complain. */ tree -perform_implicit_conversion (tree type, tree expr) +perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain) { conversion *conv; void *p; @@ -6624,7 +6706,8 @@ perform_implicit_conversion (tree type, tree expr) LOOKUP_NORMAL); if (!conv) { - error ("could not convert %qE to %qT", expr, type); + if (complain & tf_error) + error ("could not convert %qE to %qT", expr, type); expr = error_mark_node; } else if (processing_template_decl) @@ -6636,7 +6719,7 @@ perform_implicit_conversion (tree type, tree expr) expr = build_nop (type, expr); } else - expr = convert_like (conv, expr); + expr = convert_like (conv, expr, complain); /* Free all the conversions we allocated. */ obstack_free (&conversion_obstack, p); @@ -6655,7 +6738,8 @@ perform_implicit_conversion (tree type, tree expr) tree perform_direct_initialization_if_possible (tree type, tree expr, - bool c_cast_p) + bool c_cast_p, + tsubst_flags_t complain) { conversion *conv; void *p; @@ -6674,7 +6758,7 @@ perform_direct_initialization_if_possible (tree type, { expr = build_special_member_call (NULL_TREE, complete_ctor_identifier, build_tree_list (NULL_TREE, expr), - type, LOOKUP_NORMAL); + type, LOOKUP_NORMAL, complain); return build_cplus_new (type, expr); } @@ -6689,7 +6773,8 @@ perform_direct_initialization_if_possible (tree type, else expr = convert_like_real (conv, expr, NULL_TREE, 0, 0, /*issue_conversion_warnings=*/false, - c_cast_p); + c_cast_p, + tf_warning_or_error); /* Free all the conversions we allocated. */ obstack_free (&conversion_obstack, p); @@ -6824,7 +6909,8 @@ initialize_reference (tree type, tree expr, tree decl, tree *cleanup) /*fn=*/NULL_TREE, /*argnum=*/0, /*inner=*/-1, /*issue_conversion_warnings=*/true, - /*c_cast_p=*/false); + /*c_cast_p=*/false, + tf_warning_or_error); if (error_operand_p (expr)) expr = error_mark_node; else @@ -6897,17 +6983,18 @@ initialize_reference (tree type, tree expr, tree decl, tree *cleanup) } else /* Take the address of EXPR. */ - expr = build_unary_op (ADDR_EXPR, expr, 0); + expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error); /* If a BASE_CONV was required, perform it now. */ if (base_conv_type) expr = (perform_implicit_conversion - (build_pointer_type (base_conv_type), expr)); + (build_pointer_type (base_conv_type), expr, + tf_warning_or_error)); expr = build_nop (type, expr); } } else /* Perform the conversion. */ - expr = convert_like (conv, expr); + expr = convert_like (conv, expr, tf_warning_or_error); /* Free all the conversions we allocated. */ obstack_free (&conversion_obstack, p); diff --git a/gcc/cp/class.c b/gcc/cp/class.c index 154c3b3fc37..69acf11cdfc 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -284,7 +284,7 @@ build_base_path (enum tree_code code, if (!want_pointer) /* This must happen before the call to save_expr. */ - expr = build_unary_op (ADDR_EXPR, expr, 0); + expr = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error); offset = BINFO_OFFSET (binfo); fixed_type_p = resolves_to_fixed_type_p (expr, &nonnull); @@ -345,7 +345,7 @@ build_base_path (enum tree_code code, interesting to the optimizers anyway. */ && !has_empty) { - expr = build_indirect_ref (expr, NULL); + expr = cp_build_indirect_ref (expr, NULL, tf_warning_or_error); expr = build_simple_base_path (expr, binfo); if (want_pointer) expr = build_address (expr); @@ -370,10 +370,12 @@ build_base_path (enum tree_code code, t = TREE_TYPE (TYPE_VFIELD (current_class_type)); t = build_pointer_type (t); v_offset = convert (t, current_vtt_parm); - v_offset = build_indirect_ref (v_offset, NULL); + v_offset = cp_build_indirect_ref (v_offset, NULL, + tf_warning_or_error); } else - v_offset = build_vfield_ref (build_indirect_ref (expr, NULL), + v_offset = build_vfield_ref (cp_build_indirect_ref (expr, NULL, + tf_warning_or_error), TREE_TYPE (TREE_TYPE (expr))); v_offset = build2 (POINTER_PLUS_EXPR, TREE_TYPE (v_offset), @@ -381,7 +383,7 @@ build_base_path (enum tree_code code, v_offset = build1 (NOP_EXPR, build_pointer_type (ptrdiff_type_node), v_offset); - v_offset = build_indirect_ref (v_offset, NULL); + v_offset = cp_build_indirect_ref (v_offset, NULL, tf_warning_or_error); TREE_CONSTANT (v_offset) = 1; TREE_INVARIANT (v_offset) = 1; @@ -425,7 +427,7 @@ build_base_path (enum tree_code code, null_test = NULL; if (!want_pointer) - expr = build_indirect_ref (expr, NULL); + expr = cp_build_indirect_ref (expr, NULL, tf_warning_or_error); out: if (null_test) @@ -459,7 +461,7 @@ build_simple_base_path (tree expr, tree binfo) in the back end. */ temp = unary_complex_lvalue (ADDR_EXPR, expr); if (temp) - expr = build_indirect_ref (temp, NULL); + expr = cp_build_indirect_ref (temp, NULL, tf_warning_or_error); return expr; } @@ -551,7 +553,8 @@ convert_to_base_statically (tree expr, tree base) when processing a template because they do not handle C++-specific trees. */ gcc_assert (!processing_template_decl); - expr = build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1); + expr = cp_build_unary_op (ADDR_EXPR, expr, /*noconvert=*/1, + tf_warning_or_error); if (!integer_zerop (BINFO_OFFSET (base))) expr = fold_build2 (POINTER_PLUS_EXPR, pointer_type, expr, fold_convert (sizetype, BINFO_OFFSET (base))); @@ -648,13 +651,16 @@ build_vfn_ref (tree instance_ptr, tree idx) { tree aref; - aref = build_vtbl_ref_1 (build_indirect_ref (instance_ptr, 0), idx); + aref = build_vtbl_ref_1 (cp_build_indirect_ref (instance_ptr, 0, + tf_warning_or_error), + idx); /* When using function descriptors, the address of the vtable entry is treated as a function pointer. */ if (TARGET_VTABLE_USES_DESCRIPTORS) aref = build1 (NOP_EXPR, TREE_TYPE (aref), - build_unary_op (ADDR_EXPR, aref, /*noconvert=*/1)); + cp_build_unary_op (ADDR_EXPR, aref, /*noconvert=*/1, + tf_warning_or_error)); /* Remember this as a method reference, for later devirtualization. */ aref = build3 (OBJ_TYPE_REF, TREE_TYPE (aref), aref, instance_ptr, idx); @@ -6098,10 +6104,10 @@ resolve_address_of_overloaded_function (tree target_type, } if (TYPE_PTRFN_P (target_type) || TYPE_PTRMEMFUNC_P (target_type)) - return build_unary_op (ADDR_EXPR, fn, 0); + return cp_build_unary_op (ADDR_EXPR, fn, 0, flags); else { - /* The target must be a REFERENCE_TYPE. Above, build_unary_op + /* The target must be a REFERENCE_TYPE. Above, cp_build_unary_op will mark the function as addressed, but here we must do it explicitly. */ cxx_mark_addressable (fn); diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 9afeed71fbe..8387fd790e0 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -4061,7 +4061,8 @@ extern cp_parameter_declarator *no_parameters; extern bool check_dtor_name (tree, tree); extern tree build_vfield_ref (tree, tree); -extern tree build_conditional_expr (tree, tree, tree); +extern tree build_conditional_expr (tree, tree, tree, + tsubst_flags_t); extern tree build_addr_func (tree); extern tree build_call_a (tree, int, tree*); extern tree build_call_n (tree, int, ...); @@ -4069,13 +4070,17 @@ extern bool null_ptr_cst_p (tree); extern bool sufficient_parms_p (const_tree); extern tree type_decays_to (tree); extern tree build_user_type_conversion (tree, tree, int); -extern tree build_new_function_call (tree, tree, bool); +extern tree build_new_function_call (tree, tree, bool, + tsubst_flags_t); extern tree build_operator_new_call (tree, tree, tree *, tree *, tree *); extern tree build_new_method_call (tree, tree, tree, tree, int, - tree *); -extern tree build_special_member_call (tree, tree, tree, tree, int); -extern tree build_new_op (enum tree_code, int, tree, tree, tree, bool *); + tree *, tsubst_flags_t); +extern tree build_special_member_call (tree, tree, tree, tree, int, + tsubst_flags_t); +extern tree build_new_op (enum tree_code, int, tree, + tree, tree, bool *, + tsubst_flags_t); extern tree build_op_delete_call (enum tree_code, tree, tree, bool, tree, tree); extern bool can_convert (tree, tree); extern bool can_convert_arg (tree, tree, tree, int); @@ -4091,8 +4096,9 @@ extern bool is_properly_derived_from (tree, tree); extern tree initialize_reference (tree, tree, tree, tree *); extern tree make_temporary_var_for_ref_to_temp (tree, tree); extern tree strip_top_quals (tree); -extern tree perform_implicit_conversion (tree, tree); -extern tree perform_direct_initialization_if_possible (tree, tree, bool); +extern tree perform_implicit_conversion (tree, tree, tsubst_flags_t); +extern tree perform_direct_initialization_if_possible (tree, tree, bool, + tsubst_flags_t); extern tree in_charge_arg_for_name (tree); extern tree build_cxx_call (tree, int, tree *); #ifdef ENABLE_CHECKING @@ -4159,7 +4165,8 @@ extern tree force_rvalue (tree); extern tree ocp_convert (tree, tree, int, int); extern tree cp_convert (tree, tree); extern tree cp_convert_and_check (tree, tree); -extern tree convert_to_void (tree, const char */*implicit context*/); +extern tree convert_to_void (tree, const char */*implicit context*/, + tsubst_flags_t); extern tree convert_force (tree, tree, int); extern tree build_expr_type_conversion (int, tree, bool); extern tree type_promotes_to (tree); @@ -4336,14 +4343,17 @@ extern tree do_friend (tree, tree, tree, tree, enum overload_flags, bool); /* in init.c */ extern tree expand_member_init (tree); extern void emit_mem_initializers (tree); -extern tree build_aggr_init (tree, tree, int); +extern tree build_aggr_init (tree, tree, int, + tsubst_flags_t); extern int is_class_type (tree, int); extern tree get_type_value (tree); extern tree build_zero_init (tree, tree, bool); extern tree build_value_init (tree); extern tree build_offset_ref (tree, tree, bool); -extern tree build_new (tree, tree, tree, tree, int); -extern tree build_vec_init (tree, tree, tree, bool, int); +extern tree build_new (tree, tree, tree, tree, int, + tsubst_flags_t); +extern tree build_vec_init (tree, tree, tree, bool, int, + tsubst_flags_t); extern tree build_default_init (tree, tree); extern tree build_delete (tree, tree, special_function_kind, @@ -4482,7 +4492,7 @@ extern tree build_typeid (tree); extern tree get_tinfo_decl (tree); extern tree get_typeid (tree); extern tree build_headof (tree); -extern tree build_dynamic_cast (tree, tree); +extern tree build_dynamic_cast (tree, tree, tsubst_flags_t); extern void emit_support_tinfos (void); extern bool emit_tinfo_decl (tree); @@ -4613,7 +4623,8 @@ extern tree finish_stmt_expr_expr (tree, tree); extern tree finish_stmt_expr (tree, bool); extern tree stmt_expr_value_expr (tree); extern tree perform_koenig_lookup (tree, tree); -extern tree finish_call_expr (tree, tree, bool, bool); +extern tree finish_call_expr (tree, tree, bool, bool, + tsubst_flags_t); extern tree finish_increment_expr (tree, enum tree_code); extern tree finish_this_expr (void); extern tree finish_pseudo_destructor_expr (tree, tree, tree); @@ -4762,36 +4773,49 @@ extern bool comptypes (tree, tree, int); extern bool compparms (const_tree, const_tree); extern int comp_cv_qualification (const_tree, const_tree); extern int comp_cv_qual_signature (tree, tree); -extern tree cxx_sizeof_or_alignof_expr (tree, enum tree_code); +extern tree cxx_sizeof_or_alignof_expr (tree, enum tree_code, bool); extern tree cxx_sizeof_or_alignof_type (tree, enum tree_code, bool); -#define cxx_sizeof_nowarn(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, false) +extern tree cxx_sizeof_nowarn (tree); extern tree inline_conversion (tree); extern tree is_bitfield_expr_with_lowered_type (const_tree); extern tree unlowered_expr_type (const_tree); extern tree decay_conversion (tree); -extern tree build_class_member_access_expr (tree, tree, tree, bool); -extern tree finish_class_member_access_expr (tree, tree, bool); -extern tree build_x_indirect_ref (tree, const char *); -extern tree build_indirect_ref (tree, const char *); +extern tree build_class_member_access_expr (tree, tree, tree, bool, + tsubst_flags_t); +extern tree finish_class_member_access_expr (tree, tree, bool, + tsubst_flags_t); +extern tree build_x_indirect_ref (tree, const char *, + tsubst_flags_t); +extern tree cp_build_indirect_ref (tree, const char *, + tsubst_flags_t); extern tree build_array_ref (tree, tree); extern tree get_member_function_from_ptrfunc (tree *, tree); +extern tree cp_build_function_call (tree, tree, tsubst_flags_t); extern tree build_x_binary_op (enum tree_code, tree, enum tree_code, tree, - enum tree_code, bool *); -extern tree build_x_unary_op (enum tree_code, tree); + enum tree_code, bool *, + tsubst_flags_t); +extern tree build_x_unary_op (enum tree_code, tree, + tsubst_flags_t); +extern tree cp_build_unary_op (enum tree_code, tree, int, + tsubst_flags_t); extern tree unary_complex_lvalue (enum tree_code, tree); -extern tree build_x_conditional_expr (tree, tree, tree); +extern tree build_x_conditional_expr (tree, tree, tree, + tsubst_flags_t); extern tree build_x_compound_expr_from_list (tree, const char *); -extern tree build_x_compound_expr (tree, tree); -extern tree build_compound_expr (tree, tree); -extern tree build_static_cast (tree, tree); -extern tree build_reinterpret_cast (tree, tree); -extern tree build_const_cast (tree, tree); -extern tree build_c_cast (tree, tree); -extern tree build_x_modify_expr (tree, enum tree_code, tree); -extern tree build_modify_expr (tree, enum tree_code, tree); +extern tree build_x_compound_expr (tree, tree, tsubst_flags_t); +extern tree build_compound_expr (tree, tree, tsubst_flags_t); +extern tree build_static_cast (tree, tree, tsubst_flags_t); +extern tree build_reinterpret_cast (tree, tree, tsubst_flags_t); +extern tree build_const_cast (tree, tree, tsubst_flags_t); +extern tree build_c_cast (tree, tree, tsubst_flags_t); +extern tree build_x_modify_expr (tree, enum tree_code, tree, + tsubst_flags_t); +extern tree cp_build_modify_expr (tree, enum tree_code, tree, + tsubst_flags_t); extern tree convert_for_initialization (tree, tree, tree, int, - const char *, tree, int); + const char *, tree, int, + tsubst_flags_t); extern int comp_ptr_ttypes (tree, tree); extern bool comp_ptr_ttypes_const (tree, tree); extern int ptr_reasonably_similar (const_tree, const_tree); @@ -4805,21 +4829,22 @@ extern tree build_ptrmemfunc1 (tree, tree, tree); extern void expand_ptrmemfunc_cst (tree, tree *, tree *); extern tree type_after_usual_arithmetic_conversions (tree, tree); extern tree composite_pointer_type (tree, tree, tree, tree, - const char*); + const char*, tsubst_flags_t); extern tree merge_types (tree, tree); extern tree check_return_expr (tree, bool *); -#define cp_build_binary_op(code, arg1, arg2) \ - build_binary_op(code, arg1, arg2, 1) +extern tree cp_build_binary_op (enum tree_code, tree, tree, + tsubst_flags_t); #define cxx_sizeof(T) cxx_sizeof_or_alignof_type (T, SIZEOF_EXPR, true) extern tree build_ptrmemfunc_access_expr (tree, tree); extern tree build_address (tree); extern tree build_nop (tree, tree); extern tree non_reference (tree); extern tree lookup_anon_field (tree, tree); -extern bool invalid_nonstatic_memfn_p (const_tree); +extern bool invalid_nonstatic_memfn_p (const_tree, tsubst_flags_t); extern tree convert_member_func_to_ptr (tree, tree); extern tree convert_ptrmem (tree, tree, bool, bool); -extern int lvalue_or_else (const_tree, enum lvalue_use); +extern int lvalue_or_else (const_tree, enum lvalue_use, + tsubst_flags_t); extern int lvalue_p (const_tree); /* in typeck2.c */ @@ -4840,7 +4865,7 @@ extern tree digest_init (tree, tree); extern tree build_scoped_ref (tree, tree, tree *); extern tree build_x_arrow (tree); extern tree build_m_component_ref (tree, tree); -extern tree build_functional_cast (tree, tree); +extern tree build_functional_cast (tree, tree, tsubst_flags_t); extern tree add_exception_specifier (tree, tree, int); extern tree merge_exception_specifiers (tree, tree); diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c index 64a871650e1..fe1ed29ec65 100644 --- a/gcc/cp/cvt.c +++ b/gcc/cp/cvt.c @@ -326,7 +326,7 @@ build_up_reference (tree type, tree arg, int flags, tree decl) /* If we had a way to wrap this up, and say, if we ever needed its address, transform all occurrences of the register, into a memory reference we could win better. */ - rval = build_unary_op (ADDR_EXPR, arg, 1); + rval = cp_build_unary_op (ADDR_EXPR, arg, 1, tf_warning_or_error); if (rval == error_mark_node) return error_mark_node; @@ -470,7 +470,7 @@ convert_to_reference (tree reftype, tree expr, int convtype, warning (0, "casting %qT to %qT does not dereference pointer", intype, reftype); - rval = build_unary_op (ADDR_EXPR, expr, 0); + rval = cp_build_unary_op (ADDR_EXPR, expr, 0, tf_warning_or_error); if (rval != error_mark_node) rval = convert_force (build_pointer_type (TREE_TYPE (reftype)), rval, 0); @@ -480,7 +480,8 @@ convert_to_reference (tree reftype, tree expr, int convtype, else { rval = convert_for_initialization (NULL_TREE, type, expr, flags, - "converting", 0, 0); + "converting", 0, 0, + tf_warning_or_error); if (rval == NULL_TREE || rval == error_mark_node) return rval; warn_ref_binding (reftype, intype, decl); @@ -630,7 +631,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags) if (code == VOID_TYPE && (convtype & CONV_STATIC)) { - e = convert_to_void (e, /*implicit=*/NULL); + e = convert_to_void (e, /*implicit=*/NULL, tf_warning_or_error); return e; } @@ -734,7 +735,8 @@ ocp_convert (tree type, tree expr, int convtype, int flags) ctor = build_special_member_call (NULL_TREE, complete_ctor_identifier, build_tree_list (NULL_TREE, ctor), - type, flags); + type, flags, + tf_warning_or_error); if (ctor) return build_cplus_new (type, ctor); } @@ -763,18 +765,19 @@ ocp_convert (tree type, tree expr, int convtype, int flags) IMPLICIT is tells us the context of an implicit void conversion. */ tree -convert_to_void (tree expr, const char *implicit) +convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain) { if (expr == error_mark_node || TREE_TYPE (expr) == error_mark_node) return error_mark_node; if (!TREE_TYPE (expr)) return expr; - if (invalid_nonstatic_memfn_p (expr)) + if (invalid_nonstatic_memfn_p (expr, complain)) return error_mark_node; if (TREE_CODE (expr) == PSEUDO_DTOR_EXPR) { - error ("pseudo-destructor is not called"); + if (complain & tf_error) + error ("pseudo-destructor is not called"); return error_mark_node; } if (VOID_TYPE_P (TREE_TYPE (expr))) @@ -788,10 +791,10 @@ convert_to_void (tree expr, const char *implicit) tree op2 = TREE_OPERAND (expr,2); tree new_op1 = convert_to_void (op1, (implicit && !TREE_SIDE_EFFECTS (op2) - ? "second operand of conditional" : NULL)); + ? "second operand of conditional" : NULL), complain); tree new_op2 = convert_to_void (op2, (implicit && !TREE_SIDE_EFFECTS (op1) - ? "third operand of conditional" : NULL)); + ? "third operand of conditional" : NULL), complain); expr = build3 (COND_EXPR, TREE_TYPE (new_op1), TREE_OPERAND (expr, 0), new_op1, new_op2); @@ -804,7 +807,7 @@ convert_to_void (tree expr, const char *implicit) tree op1 = TREE_OPERAND (expr,1); tree new_op1 = convert_to_void (op1, (implicit && !TREE_NO_WARNING (expr) - ? "right-hand operand of comma" : NULL)); + ? "right-hand operand of comma" : NULL), complain); if (new_op1 != op1) { @@ -834,14 +837,20 @@ convert_to_void (tree expr, const char *implicit) /* Can't load the value if we don't know the type. */ if (is_volatile && !is_complete) - warning (0, "object of incomplete type %qT will not be accessed in %s", - type, implicit ? implicit : "void context"); + { + if (complain & tf_warning) + warning (0, "object of incomplete type %qT will not be accessed in %s", + type, implicit ? implicit : "void context"); + } /* Don't load the value if this is an implicit dereference, or if the type needs to be handled by ctors/dtors. */ else if (is_volatile && (is_reference || TREE_ADDRESSABLE (type))) - warning (0, "object of type %qT will not be accessed in %s", - TREE_TYPE (TREE_OPERAND (expr, 0)), - implicit ? implicit : "void context"); + { + if (complain & tf_warning) + warning (0, "object of type %qT will not be accessed in %s", + TREE_TYPE (TREE_OPERAND (expr, 0)), + implicit ? implicit : "void context"); + } if (is_reference || !is_volatile || !is_complete || TREE_ADDRESSABLE (type)) expr = TREE_OPERAND (expr, 0); @@ -854,7 +863,7 @@ convert_to_void (tree expr, const char *implicit) tree type = TREE_TYPE (expr); int is_complete = COMPLETE_TYPE_P (complete_type (type)); - if (TYPE_VOLATILE (type) && !is_complete) + if (TYPE_VOLATILE (type) && !is_complete && (complain & tf_warning)) warning (0, "object %qE of incomplete type %qT will not be accessed in %s", expr, type, implicit ? implicit : "void context"); break; @@ -892,15 +901,19 @@ convert_to_void (tree expr, const char *implicit) { /* [over.over] enumerates the places where we can take the address of an overloaded function, and this is not one of them. */ - error ("%s cannot resolve address of overloaded function", - implicit ? implicit : "void cast"); + if (complain & tf_error) + error ("%s cannot resolve address of overloaded function", + implicit ? implicit : "void cast"); + else + return error_mark_node; expr = void_zero_node; } else if (implicit && probe == expr && is_overloaded_fn (probe)) { /* Only warn when there is no &. */ - warning (OPT_Waddress, "%s is a reference, not call, to function %qE", - implicit, expr); + if (complain & tf_warning) + warning (OPT_Waddress, "%s is a reference, not call, to function %qE", + implicit, expr); if (TREE_CODE (expr) == COMPONENT_REF) expr = TREE_OPERAND (expr, 0); } @@ -915,8 +928,10 @@ convert_to_void (tree expr, const char *implicit) { /* The middle end does not warn about expressions that have been explicitly cast to void, so we must do so here. */ - if (!TREE_SIDE_EFFECTS (expr)) - warning (OPT_Wunused_value, "%s has no effect", implicit); + if (!TREE_SIDE_EFFECTS (expr)) { + if (complain & tf_warning) + warning (OPT_Wunused_value, "%s has no effect", implicit); + } else { tree e; @@ -939,7 +954,7 @@ convert_to_void (tree expr, const char *implicit) code = TREE_CODE (e); class = TREE_CODE_CLASS (code); - if (class == tcc_comparison + if ((class == tcc_comparison || class == tcc_unary || (class == tcc_binary && !(code == MODIFY_EXPR @@ -948,6 +963,7 @@ convert_to_void (tree expr, const char *implicit) || code == PREINCREMENT_EXPR || code == POSTDECREMENT_EXPR || code == POSTINCREMENT_EXPR))) + && (complain & tf_warning)) warning (OPT_Wunused_value, "value computed is not used"); } } diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 8353b9b64c3..df0b78c1971 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -5027,7 +5027,7 @@ check_initializer (tree decl, tree init, int flags, tree *cleanup) saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p (); current_stmt_tree ()->stmts_are_full_exprs_p = 1; } - init = build_aggr_init (decl, init, flags); + init = build_aggr_init (decl, init, flags, tf_warning_or_error); if (building_stmt_tree ()) current_stmt_tree ()->stmts_are_full_exprs_p = saved_stmts_are_full_exprs_p; @@ -5978,7 +5978,7 @@ register_dtor_fn (tree decl) addr = build_address (decl); /* The declared type of the parameter to "__cxa_atexit" is "void *". For plain "T*", we could just let the - machinery in build_function_call convert it -- but if the + machinery in cp_build_function_call convert it -- but if the type is "cv-qualified T *", then we need to convert it before passing it in, to avoid spurious errors. */ addr = build_nop (ptr_type_node, addr); @@ -5990,7 +5990,8 @@ register_dtor_fn (tree decl) other value. */ addr = null_pointer_node; args = tree_cons (NULL_TREE, - build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0), + cp_build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0, + tf_warning_or_error), NULL_TREE); if (targetm.cxx.use_aeabi_atexit ()) { @@ -6005,7 +6006,8 @@ register_dtor_fn (tree decl) } else args = tree_cons (NULL_TREE, cleanup, NULL_TREE); - return build_function_call (get_atexit_node (), args); + return cp_build_function_call (get_atexit_node (), args, + tf_warning_or_error); } /* DECL is a VAR_DECL with static storage duration. INIT, if present, @@ -7082,7 +7084,8 @@ compute_array_index_type (tree name, tree size) processing_template_decl = 0; itype = cp_build_binary_op (MINUS_EXPR, cp_convert (ssizetype, size), - cp_convert (ssizetype, integer_one_node)); + cp_convert (ssizetype, integer_one_node), + tf_warning_or_error); itype = fold (itype); processing_template_decl = saved_processing_template_decl; @@ -10820,7 +10823,8 @@ finish_enum (tree enumtype) saved_location = input_location; input_location = DECL_SOURCE_LOCATION (decl); value = perform_implicit_conversion (underlying_type, - DECL_INITIAL (decl)); + DECL_INITIAL (decl), + tf_warning_or_error); input_location = saved_location; /* Do not clobber shared ints. */ @@ -11282,7 +11286,7 @@ start_preparsed_function (tree decl1, tree attrs, int flags) gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE); cp_function_chain->x_current_class_ref - = build_indirect_ref (t, NULL); + = cp_build_indirect_ref (t, NULL, tf_warning_or_error); cp_function_chain->x_current_class_ptr = t; /* Constructors and destructors need to know whether they're "in @@ -12199,8 +12203,9 @@ cxx_maybe_build_cleanup (tree decl) fn = lookup_name (id); arg = build_address (decl); mark_used (decl); - cleanup = build_function_call (fn, build_tree_list (NULL_TREE, - arg)); + cleanup = cp_build_function_call (fn, build_tree_list (NULL_TREE, + arg), + tf_warning_or_error); } /* Handle ordinary C++ destructors. */ type = TREE_TYPE (decl); @@ -12224,7 +12229,7 @@ cxx_maybe_build_cleanup (tree decl) call = build_delete (TREE_TYPE (addr), addr, sfk_complete_destructor, flags, 0); if (cleanup) - cleanup = build_compound_expr (cleanup, call); + cleanup = build_compound_expr (cleanup, call, tf_warning_or_error); else cleanup = call; } diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index 367d9eba26b..078ca99e6f8 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -311,7 +311,7 @@ grok_array_decl (tree array_expr, tree index_exp) if (MAYBE_CLASS_TYPE_P (type) || MAYBE_CLASS_TYPE_P (TREE_TYPE (index_exp))) expr = build_new_op (ARRAY_REF, LOOKUP_NORMAL, array_expr, index_exp, NULL_TREE, - /*overloaded_p=*/NULL); + /*overloaded_p=*/NULL, tf_warning_or_error); else { tree p1, p2, i1, i2; @@ -1190,7 +1190,7 @@ build_anon_union_vars (tree type, tree object) DECL_NAME (field), NULL_TREE); else ref = build_class_member_access_expr (object, field, NULL_TREE, - false); + false, tf_warning_or_error); if (DECL_NAME (field)) { @@ -2436,13 +2436,15 @@ get_guard_cond (tree guard) guard_value = integer_one_node; if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard))) guard_value = convert (TREE_TYPE (guard), guard_value); - guard = cp_build_binary_op (BIT_AND_EXPR, guard, guard_value); + guard = cp_build_binary_op (BIT_AND_EXPR, guard, guard_value, + tf_warning_or_error); } guard_value = integer_zero_node; if (!same_type_p (TREE_TYPE (guard_value), TREE_TYPE (guard))) guard_value = convert (TREE_TYPE (guard), guard_value); - return cp_build_binary_op (EQ_EXPR, guard, guard_value); + return cp_build_binary_op (EQ_EXPR, guard, guard_value, + tf_warning_or_error); } /* Return an expression which sets the GUARD variable, indicating that @@ -2458,7 +2460,8 @@ set_guard (tree guard) guard_init = integer_one_node; if (!same_type_p (TREE_TYPE (guard_init), TREE_TYPE (guard))) guard_init = convert (TREE_TYPE (guard), guard_init); - return build_modify_expr (guard, NOP_EXPR, guard_init); + return cp_build_modify_expr (guard, NOP_EXPR, guard_init, + tf_warning_or_error); } /* Start the process of running a particular set of global constructors @@ -2787,17 +2790,21 @@ one_static_initialization_or_destruction (tree decl, tree init, bool initp) else if (initp) guard_cond = cp_build_binary_op (EQ_EXPR, - build_unary_op (PREINCREMENT_EXPR, + cp_build_unary_op (PREINCREMENT_EXPR, guard, - /*noconvert=*/1), - integer_one_node); + /*noconvert=*/1, + tf_warning_or_error), + integer_one_node, + tf_warning_or_error); else guard_cond = cp_build_binary_op (EQ_EXPR, - build_unary_op (PREDECREMENT_EXPR, + cp_build_unary_op (PREDECREMENT_EXPR, guard, - /*noconvert=*/1), - integer_zero_node); + /*noconvert=*/1, + tf_warning_or_error), + integer_zero_node, + tf_warning_or_error); guard_if_stmt = begin_if_stmt (); finish_if_stmt_cond (guard_cond, guard_if_stmt); @@ -2849,8 +2856,9 @@ do_static_initialization_or_destruction (tree vars, bool initp) init_if_stmt = begin_if_stmt (); cond = initp ? integer_one_node : integer_zero_node; cond = cp_build_binary_op (EQ_EXPR, - initialize_p_decl, - cond); + initialize_p_decl, + cond, + tf_warning_or_error); finish_if_stmt_cond (cond, init_if_stmt); node = vars; @@ -2882,7 +2890,8 @@ do_static_initialization_or_destruction (tree vars, bool initp) priority_if_stmt = begin_if_stmt (); cond = cp_build_binary_op (EQ_EXPR, priority_decl, - build_int_cst (NULL_TREE, priority)); + build_int_cst (NULL_TREE, priority), + tf_warning_or_error); finish_if_stmt_cond (cond, priority_if_stmt); /* Process initializers with same priority. */ @@ -3031,7 +3040,8 @@ generate_ctor_or_dtor_function (bool constructor_p, int priority, arguments = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, constructor_p), arguments); - finish_expr_stmt (build_function_call (fndecl, arguments)); + finish_expr_stmt (cp_build_function_call (fndecl, arguments, + tf_warning_or_error)); } } @@ -3534,7 +3544,7 @@ build_offset_ref_call_from_tree (tree fn, tree args) args = build_non_dependent_args (args); object = build_non_dependent_expr (object); if (TREE_CODE (fn) == DOTSTAR_EXPR) - object = build_unary_op (ADDR_EXPR, object, 0); + object = cp_build_unary_op (ADDR_EXPR, object, 0, tf_warning_or_error); args = tree_cons (NULL_TREE, object, args); /* Now that the arguments are done, transform FN. */ fn = build_non_dependent_expr (fn); @@ -3548,13 +3558,14 @@ build_offset_ref_call_from_tree (tree fn, tree args) void B::g() { (this->*p)(); } */ if (TREE_CODE (fn) == OFFSET_REF) { - tree object_addr = build_unary_op (ADDR_EXPR, object, 0); + tree object_addr = cp_build_unary_op (ADDR_EXPR, object, 0, + tf_warning_or_error); fn = TREE_OPERAND (fn, 1); fn = get_member_function_from_ptrfunc (&object_addr, fn); args = tree_cons (NULL_TREE, object_addr, args); } - expr = build_function_call (fn, args); + expr = cp_build_function_call (fn, args, tf_warning_or_error); if (processing_template_decl && expr != error_mark_node) return build_min_non_dep_call_list (expr, orig_fn, orig_args); return expr; diff --git a/gcc/cp/except.c b/gcc/cp/except.c index 38111b16338..5304381a499 100644 --- a/gcc/cp/except.c +++ b/gcc/cp/except.c @@ -176,8 +176,9 @@ do_get_exception_ptr (void) fn = push_library_fn (fn, build_function_type (ptr_type_node, tmp)); } - return build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (), - NULL_TREE)); + return cp_build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (), + NULL_TREE), + tf_warning_or_error); } /* Build up a call to __cxa_begin_catch, to tell the runtime that the @@ -196,8 +197,9 @@ do_begin_catch (void) fn = push_library_fn (fn, build_function_type (ptr_type_node, tmp)); } - return build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (), - NULL_TREE)); + return cp_build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (), + NULL_TREE), + tf_warning_or_error); } /* Returns nonzero if cleaning up an exception of type TYPE (which can be @@ -235,7 +237,7 @@ do_end_catch (tree type) TREE_NOTHROW (fn) = 0; } - cleanup = build_function_call (fn, NULL_TREE); + cleanup = cp_build_function_call (fn, NULL_TREE, tf_warning_or_error); TREE_NOTHROW (cleanup) = dtor_nothrow (type); return cleanup; @@ -377,7 +379,7 @@ initialize_handler_parm (tree decl, tree exp) pointer catch parm with the address of the temporary. */ if (TREE_CODE (init_type) == REFERENCE_TYPE && TYPE_PTR_P (TREE_TYPE (init_type))) - exp = build_unary_op (ADDR_EXPR, exp, 1); + exp = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error); exp = ocp_convert (init_type, exp, CONV_IMPLICIT|CONV_FORCE_TEMP, 0); @@ -434,7 +436,7 @@ expand_start_catch_block (tree decl) exp = build2 (POINTER_PLUS_EXPR, TREE_TYPE (exp), exp, fold_build1 (NEGATE_EXPR, sizetype, TYPE_SIZE_UNIT (TREE_TYPE (exp)))); - exp = build_indirect_ref (exp, NULL); + exp = cp_build_indirect_ref (exp, NULL, tf_warning_or_error); initialize_handler_parm (decl, exp); return type; } @@ -546,8 +548,10 @@ do_allocate_exception (tree type) fn = push_library_fn (fn, build_function_type (ptr_type_node, tmp)); } - return build_function_call (fn, tree_cons (NULL_TREE, size_in_bytes (type), - NULL_TREE)); + return cp_build_function_call (fn, + tree_cons (NULL_TREE, size_in_bytes (type), + NULL_TREE), + tf_warning_or_error); } /* Call __cxa_free_exception from a cleanup. This is never invoked @@ -566,7 +570,8 @@ do_free_exception (tree ptr) void_list_node)); } - return build_function_call (fn, tree_cons (NULL_TREE, ptr, NULL_TREE)); + return cp_build_function_call (fn, tree_cons (NULL_TREE, ptr, NULL_TREE), + tf_warning_or_error); } /* Wrap all cleanups for TARGET_EXPRs in MUST_NOT_THROW_EXPR. @@ -644,7 +649,8 @@ build_throw (tree exp) return error_mark_node; } fn = OVL_CURRENT (fn); - exp = build_function_call (fn, tree_cons (NULL_TREE, exp, NULL_TREE)); + exp = cp_build_function_call (fn, tree_cons (NULL_TREE, exp, NULL_TREE), + tf_warning_or_error); } else if (exp) { @@ -708,7 +714,7 @@ build_throw (tree exp) allocate_expr = get_target_expr (allocate_expr); ptr = TARGET_EXPR_SLOT (allocate_expr); object = build_nop (build_pointer_type (temp_type), ptr); - object = build_indirect_ref (object, NULL); + object = cp_build_indirect_ref (object, NULL, tf_warning_or_error); elided = (TREE_CODE (exp) == TARGET_EXPR); @@ -733,7 +739,7 @@ build_throw (tree exp) (object, complete_ctor_identifier, build_tree_list (NULL_TREE, exp), TREE_TYPE (object), - flags)); + flags, tf_warning_or_error)); if (exp == error_mark_node) { error (" in thrown expression"); @@ -812,7 +818,7 @@ build_throw (tree exp) tmp = tree_cons (NULL_TREE, throw_type, tmp); tmp = tree_cons (NULL_TREE, ptr, tmp); /* ??? Indicate that this function call throws throw_type. */ - tmp = build_function_call (fn, tmp); + tmp = cp_build_function_call (fn, tmp, tf_warning_or_error); /* Tack on the initialization stuff. */ exp = build2 (COMPOUND_EXPR, TREE_TYPE (tmp), exp, tmp); @@ -831,7 +837,7 @@ build_throw (tree exp) /* ??? Indicate that this function call allows exceptions of the type of the enclosing catch block (if known). */ - exp = build_function_call (fn, NULL_TREE); + exp = cp_build_function_call (fn, NULL_TREE, tf_warning_or_error); } exp = build1 (THROW_EXPR, void_type_node, exp); diff --git a/gcc/cp/init.c b/gcc/cp/init.c index e0700eacb4f..dc4e988a3ee 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -39,8 +39,8 @@ along with GCC; see the file COPYING3. If not see static bool begin_init_stmts (tree *, tree *); static tree finish_init_stmts (bool, tree, tree); static void construct_virtual_base (tree, tree); -static void expand_aggr_init_1 (tree, tree, tree, tree, int); -static void expand_default_init (tree, tree, tree, tree, int); +static void expand_aggr_init_1 (tree, tree, tree, tree, int, tsubst_flags_t); +static void expand_default_init (tree, tree, tree, tree, int, tsubst_flags_t); static tree build_vec_delete_1 (tree, tree, tree, special_function_kind, int); static void perform_member_init (tree, tree); static tree build_builtin_delete_call (tree); @@ -353,7 +353,8 @@ build_value_init_1 (tree type, bool have_ctor) return build_cplus_new (type, build_special_member_call (NULL_TREE, complete_ctor_identifier, - NULL_TREE, type, LOOKUP_NORMAL)); + NULL_TREE, type, LOOKUP_NORMAL, + tf_warning_or_error)); else if (TREE_CODE (type) != UNION_TYPE) { tree field, init; @@ -401,7 +402,7 @@ build_value_init_1 (tree type, bool have_ctor) cp_gimplify_init_expr will know how to handle it. */ tree ctor = build_special_member_call (NULL_TREE, complete_ctor_identifier, - NULL_TREE, type, LOOKUP_NORMAL); + NULL_TREE, type, LOOKUP_NORMAL, tf_warning_or_error); ctor = build_cplus_new (type, ctor); init = build2 (INIT_EXPR, void_type_node, @@ -487,7 +488,8 @@ perform_member_init (tree member, tree init) /* Get an lvalue for the data member. */ decl = build_class_member_access_expr (current_class_ref, member, /*access_path=*/NULL_TREE, - /*preserve_reference=*/true); + /*preserve_reference=*/true, + tf_warning_or_error); if (decl == error_mark_node) return; @@ -513,10 +515,12 @@ perform_member_init (tree member, tree init) /* Initialization of one array from another. */ finish_expr_stmt (build_vec_init (decl, NULL_TREE, TREE_VALUE (init), /*explicit_default_init_p=*/false, - /* from_array=*/1)); + /* from_array=*/1, + tf_warning_or_error)); } else - finish_expr_stmt (build_aggr_init (decl, init, 0)); + finish_expr_stmt (build_aggr_init (decl, init, 0, + tf_warning_or_error)); } else { @@ -544,7 +548,8 @@ perform_member_init (tree member, tree init) init = build_x_compound_expr_from_list (init, "member initializer"); if (init) - finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init)); + finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init, + tf_warning_or_error)); } if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)) @@ -553,7 +558,8 @@ perform_member_init (tree member, tree init) expr = build_class_member_access_expr (current_class_ref, member, /*access_path=*/NULL_TREE, - /*preserve_reference=*/false); + /*preserve_reference=*/false, + tf_warning_or_error); expr = build_delete (type, expr, sfk_complete_destructor, LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0); @@ -855,9 +861,11 @@ emit_mem_initializers (tree mem_inits) base_addr = build_base_path (PLUS_EXPR, current_class_ptr, subobject, 1); expand_aggr_init_1 (subobject, NULL_TREE, - build_indirect_ref (base_addr, NULL), + cp_build_indirect_ref (base_addr, NULL, + tf_warning_or_error), arguments, - LOOKUP_NORMAL); + LOOKUP_NORMAL, + tf_warning_or_error); expand_cleanup_for_base (subobject, NULL_TREE); } @@ -938,7 +946,7 @@ expand_virtual_init (tree binfo, tree decl) TREE_TYPE (vtt_parm), vtt_parm, vtt_index); - vtbl2 = build_indirect_ref (vtbl2, NULL); + vtbl2 = cp_build_indirect_ref (vtbl2, NULL, tf_warning_or_error); vtbl2 = convert (TREE_TYPE (vtbl), vtbl2); /* The actual initializer is the VTT value only in the subobject @@ -953,13 +961,15 @@ expand_virtual_init (tree binfo, tree decl) } /* Compute the location of the vtpr. */ - vtbl_ptr = build_vfield_ref (build_indirect_ref (decl, NULL), + vtbl_ptr = build_vfield_ref (cp_build_indirect_ref (decl, NULL, + tf_warning_or_error), TREE_TYPE (binfo)); gcc_assert (vtbl_ptr != error_mark_node); /* Assign the vtable to the vptr. */ vtbl = convert_force (TREE_TYPE (vtbl_ptr), vtbl, 0); - finish_expr_stmt (build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl)); + finish_expr_stmt (cp_build_modify_expr (vtbl_ptr, NOP_EXPR, vtbl, + tf_warning_or_error)); } /* If an exception is thrown in a constructor, those base classes already @@ -981,7 +991,8 @@ expand_cleanup_for_base (tree binfo, tree flag) base_dtor_identifier, NULL_TREE, binfo, - LOOKUP_NORMAL | LOOKUP_NONVIRTUAL); + LOOKUP_NORMAL | LOOKUP_NONVIRTUAL, + tf_warning_or_error); if (flag) expr = fold_build3 (COND_EXPR, void_type_node, c_common_truthvalue_conversion (flag), @@ -1025,7 +1036,7 @@ construct_virtual_base (tree vbase, tree arguments) exp = convert_to_base_statically (current_class_ref, vbase); expand_aggr_init_1 (vbase, current_class_ref, exp, arguments, - LOOKUP_COMPLAIN); + LOOKUP_COMPLAIN, tf_warning_or_error); finish_then_clause (inner_if_stmt); finish_if_stmt (inner_if_stmt); @@ -1230,7 +1241,7 @@ expand_member_init (tree name) perform the initialization, but not both, as it would be ambiguous. */ tree -build_aggr_init (tree exp, tree init, int flags) +build_aggr_init (tree exp, tree init, int flags, tsubst_flags_t complain) { tree stmt_expr; tree compound_stmt; @@ -1257,7 +1268,8 @@ build_aggr_init (tree exp, tree init, int flags) initialization form -- unless the initializer is "()". */ if (init && TREE_CODE (init) == TREE_LIST) { - error ("bad array initializer"); + if (complain & tf_error) + error ("bad array initializer"); return error_mark_node; } /* Must arrange to initialize each element of EXP @@ -1270,7 +1282,8 @@ build_aggr_init (tree exp, tree init, int flags) stmt_expr = build_vec_init (exp, NULL_TREE, init, /*explicit_default_init_p=*/false, itype && same_type_p (itype, - TREE_TYPE (exp))); + TREE_TYPE (exp)), + complain); TREE_READONLY (exp) = was_const; TREE_THIS_VOLATILE (exp) = was_volatile; TREE_TYPE (exp) = type; @@ -1287,7 +1300,7 @@ build_aggr_init (tree exp, tree init, int flags) destroy_temps = stmts_are_full_exprs_p (); current_stmt_tree ()->stmts_are_full_exprs_p = 0; expand_aggr_init_1 (TYPE_BINFO (type), exp, exp, - init, LOOKUP_NORMAL|flags); + init, LOOKUP_NORMAL|flags, complain); stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt); current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps; TREE_READONLY (exp) = was_const; @@ -1297,7 +1310,8 @@ build_aggr_init (tree exp, tree init, int flags) } static void -expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags) +expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags, + tsubst_flags_t complain) { tree type = TREE_TYPE (exp); tree ctor_name; @@ -1364,9 +1378,10 @@ expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags) else ctor_name = base_ctor_identifier; - rval = build_special_member_call (exp, ctor_name, parms, binfo, flags); + rval = build_special_member_call (exp, ctor_name, parms, binfo, flags, + complain); if (TREE_SIDE_EFFECTS (rval)) - finish_expr_stmt (convert_to_void (rval, NULL)); + finish_expr_stmt (convert_to_void (rval, NULL, complain)); } /* This function is responsible for initializing EXP with INIT @@ -1390,7 +1405,8 @@ expand_default_init (tree binfo, tree true_exp, tree exp, tree init, int flags) for its description. */ static void -expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags) +expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags, + tsubst_flags_t complain) { tree type = TREE_TYPE (exp); @@ -1417,7 +1433,7 @@ expand_aggr_init_1 (tree binfo, tree true_exp, tree exp, tree init, int flags) /* We know that expand_default_init can handle everything we want at this point. */ - expand_default_init (binfo, true_exp, exp, init, flags); + expand_default_init (binfo, true_exp, exp, init, flags, complain); } /* Report an error if TYPE is not a user-defined, class type. If @@ -1574,7 +1590,8 @@ build_offset_ref (tree type, tree member, bool address_p) if (flag_ms_extensions) { PTRMEM_OK_P (member) = 1; - return build_unary_op (ADDR_EXPR, member, 0); + return cp_build_unary_op (ADDR_EXPR, member, 0, + tf_warning_or_error); } error ("invalid use of non-static member function %qD", TREE_OPERAND (member, 1)); @@ -1765,7 +1782,7 @@ avoid_placement_new_aliasing (tree t, tree placement) static tree build_new_1 (tree placement, tree type, tree nelts, tree init, - bool globally_qualified_p) + bool globally_qualified_p, tsubst_flags_t complain) { tree size, rval; /* True iff this is a call to "operator new[]" instead of just @@ -1855,11 +1872,13 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, TREE_CODE (elt_type) == ARRAY_TYPE; elt_type = TREE_TYPE (elt_type)) nelts = cp_build_binary_op (MULT_EXPR, nelts, - array_type_nelts_top (elt_type)); + array_type_nelts_top (elt_type), + complain); if (TREE_CODE (elt_type) == VOID_TYPE) { - error ("invalid type % for new"); + if (complain & tf_error) + error ("invalid type % for new"); return error_mark_node; } @@ -1869,7 +1888,8 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, is_initialized = (TYPE_NEEDS_CONSTRUCTING (elt_type) || init); if (CP_TYPE_CONST_P (elt_type) && !is_initialized) { - error ("uninitialized const in % of %q#T", elt_type); + if (complain & tf_error) + error ("uninitialized const in % of %q#T", elt_type); return error_mark_node; } @@ -1907,19 +1927,22 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, if (!get_global_value_if_present (get_identifier (alloc_name), &alloc_fn)) { - error ("call to Java constructor with %qs undefined", alloc_name); + if (complain & tf_error) + error ("call to Java constructor with %qs undefined", alloc_name); return error_mark_node; } else if (really_overloaded_fn (alloc_fn)) { - error ("%qD should never be overloaded", alloc_fn); + if (complain & tf_error) + error ("%qD should never be overloaded", alloc_fn); return error_mark_node; } alloc_fn = OVL_CURRENT (alloc_fn); class_addr = build1 (ADDR_EXPR, jclass_node, class_decl); - alloc_call = (build_function_call + alloc_call = (cp_build_function_call (alloc_fn, - build_tree_list (NULL_TREE, class_addr))); + build_tree_list (NULL_TREE, class_addr), + complain)); } else if (TYPE_FOR_JAVA (elt_type) && MAYBE_CLASS_TYPE_P (elt_type)) { @@ -1952,20 +1975,25 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, fns = lookup_fnfields (elt_type, fnname, /*protect=*/2); if (fns == NULL_TREE) { - error ("no suitable %qD found in class %qT", fnname, elt_type); + if (complain & tf_error) + error ("no suitable %qD found in class %qT", fnname, elt_type); return error_mark_node; } if (TREE_CODE (fns) == TREE_LIST) { - error ("request for member %qD is ambiguous", fnname); - print_candidates (fns); + if (complain & tf_error) + { + error ("request for member %qD is ambiguous", fnname); + print_candidates (fns); + } return error_mark_node; } alloc_call = build_new_method_call (build_dummy_object (elt_type), fns, args, /*conversion_path=*/NULL_TREE, LOOKUP_NORMAL, - &alloc_fn); + &alloc_fn, + complain); } else { @@ -2085,7 +2113,7 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, size_ptr_type = build_pointer_type (sizetype); cookie_ptr = build2 (POINTER_PLUS_EXPR, size_ptr_type, fold_convert (size_ptr_type, data_addr), cookie_ptr); - cookie = build_indirect_ref (cookie_ptr, NULL); + cookie = cp_build_indirect_ref (cookie_ptr, NULL, complain); cookie_expr = build2 (MODIFY_EXPR, sizetype, cookie, nelts); @@ -2096,7 +2124,7 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, fold_build1 (NEGATE_EXPR, sizetype, size_in_bytes (sizetype))); - cookie = build_indirect_ref (cookie_ptr, NULL); + cookie = cp_build_indirect_ref (cookie_ptr, NULL, complain); cookie = build2 (MODIFY_EXPR, sizetype, cookie, size_in_bytes(elt_type)); cookie_expr = build2 (COMPOUND_EXPR, TREE_TYPE (cookie_expr), @@ -2119,7 +2147,7 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, { bool stable; - init_expr = build_indirect_ref (data_addr, NULL); + init_expr = cp_build_indirect_ref (data_addr, NULL, complain); if (array_p) { @@ -2131,15 +2159,21 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, explicit_default_init_p = true; } else if (init) - pedwarn ("ISO C++ forbids initialization in array new"); - + { + if (complain & tf_error) + pedwarn ("ISO C++ forbids initialization in array new"); + else + return error_mark_node; + } init_expr = build_vec_init (init_expr, cp_build_binary_op (MINUS_EXPR, outer_nelts, - integer_one_node), + integer_one_node, + complain), init, explicit_default_init_p, - /*from_array=*/0); + /*from_array=*/0, + complain); /* An array initialization is stable because the initialization of each element is a full-expression, so the temporaries don't @@ -2156,7 +2190,8 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, init_expr = build_special_member_call (init_expr, complete_ctor_identifier, init, elt_type, - LOOKUP_NORMAL); + LOOKUP_NORMAL, + complain); stable = stabilize_init (init_expr, &init_preeval_expr); } else @@ -2171,7 +2206,8 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, gcc_assert (TREE_CODE (init) != CONSTRUCTOR || TREE_TYPE (init) != NULL_TREE); - init_expr = build_modify_expr (init_expr, INIT_EXPR, init); + init_expr = cp_build_modify_expr (init_expr, INIT_EXPR, init, + complain); stable = stabilize_init (init_expr, &init_preeval_expr); } } @@ -2263,8 +2299,10 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, if (check_new) { tree ifexp = cp_build_binary_op (NE_EXPR, alloc_node, - integer_zero_node); - rval = build_conditional_expr (ifexp, rval, alloc_node); + integer_zero_node, + complain); + rval = build_conditional_expr (ifexp, rval, alloc_node, + complain); } /* Perform the allocation before anything else, so that ALLOC_NODE @@ -2299,7 +2337,7 @@ build_new_1 (tree placement, tree type, tree nelts, tree init, tree build_new (tree placement, tree type, tree nelts, tree init, - int use_global_new) + int use_global_new, tsubst_flags_t complain) { tree rval; tree orig_placement; @@ -2333,7 +2371,12 @@ build_new (tree placement, tree type, tree nelts, tree init, if (nelts) { if (!build_expr_type_conversion (WANT_INT | WANT_ENUM, nelts, false)) - pedwarn ("size in array new must have integral type"); + { + if (complain & tf_error) + pedwarn ("size in array new must have integral type"); + else + return error_mark_node; + } nelts = cp_save_expr (cp_convert (sizetype, nelts)); } @@ -2342,13 +2385,17 @@ build_new (tree placement, tree type, tree nelts, tree init, returned by new.'' ARM 5.3.3 */ if (TREE_CODE (type) == REFERENCE_TYPE) { - error ("new cannot be applied to a reference type"); + if (complain & tf_error) + error ("new cannot be applied to a reference type"); + else + return error_mark_node; type = TREE_TYPE (type); } if (TREE_CODE (type) == FUNCTION_TYPE) { - error ("new cannot be applied to a function type"); + if (complain & tf_error) + error ("new cannot be applied to a function type"); return error_mark_node; } @@ -2358,7 +2405,7 @@ build_new (tree placement, tree type, tree nelts, tree init, if (!complete_type_or_else (type, NULL_TREE)) return error_mark_node; - rval = build_new_1 (placement, type, nelts, init, use_global_new); + rval = build_new_1 (placement, type, nelts, init, use_global_new, complain); if (rval == error_mark_node) return error_mark_node; @@ -2464,10 +2511,11 @@ build_vec_delete_1 (tree base, tree maxindex, tree type, convert (sizetype, maxindex)); tbase = create_temporary_var (ptype); - tbase_init = build_modify_expr (tbase, NOP_EXPR, - fold_build2 (POINTER_PLUS_EXPR, ptype, - fold_convert (ptype, base), - virtual_size)); + tbase_init = cp_build_modify_expr (tbase, NOP_EXPR, + fold_build2 (POINTER_PLUS_EXPR, ptype, + fold_convert (ptype, base), + virtual_size), + tf_warning_or_error); DECL_REGISTER (tbase) = 1; controller = build3 (BIND_EXPR, void_type_node, tbase, NULL_TREE, NULL_TREE); @@ -2478,14 +2526,17 @@ build_vec_delete_1 (tree base, tree maxindex, tree type, fold_convert (ptype, base))); tmp = fold_build1 (NEGATE_EXPR, sizetype, size_exp); body = build_compound_expr - (body, build_modify_expr (tbase, NOP_EXPR, - build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp))); + (body, cp_build_modify_expr (tbase, NOP_EXPR, + build2 (POINTER_PLUS_EXPR, ptype, tbase, tmp), + tf_warning_or_error), + tf_warning_or_error); body = build_compound_expr (body, build_delete (ptype, tbase, sfk_complete_destructor, - LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1)); + LOOKUP_NORMAL|LOOKUP_DESTRUCTOR, 1), + tf_warning_or_error); loop = build1 (LOOP_EXPR, void_type_node, body); - loop = build_compound_expr (tbase_init, loop); + loop = build_compound_expr (tbase_init, loop, tf_warning_or_error); no_destructor: /* If the delete flag is one, or anything else with the low bit set, @@ -2511,7 +2562,8 @@ build_vec_delete_1 (tree base, tree maxindex, tree type, cp_build_binary_op (MINUS_EXPR, cp_convert (string_type_node, base), - cookie_size)); + cookie_size, + tf_warning_or_error)); /* True size with header. */ virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size); } @@ -2530,7 +2582,7 @@ build_vec_delete_1 (tree base, tree maxindex, tree type, else if (!body) body = deallocate_expr; else - body = build_compound_expr (body, deallocate_expr); + body = build_compound_expr (body, deallocate_expr, tf_warning_or_error); if (!body) body = integer_zero_node; @@ -2553,7 +2605,7 @@ build_vec_delete_1 (tree base, tree maxindex, tree type, /* Pre-evaluate the SAVE_EXPR outside of the BIND_EXPR. */ body = build2 (COMPOUND_EXPR, void_type_node, base, body); - return convert_to_void (body, /*implicit=*/NULL); + return convert_to_void (body, /*implicit=*/NULL, tf_warning_or_error); } /* Create an unnamed variable of the indicated TYPE. */ @@ -2588,7 +2640,8 @@ get_temp_regvar (tree type, tree init) decl = create_temporary_var (type); add_decl_expr (decl); - finish_expr_stmt (build_modify_expr (decl, INIT_EXPR, init)); + finish_expr_stmt (cp_build_modify_expr (decl, INIT_EXPR, init, + tf_warning_or_error)); return decl; } @@ -2616,7 +2669,7 @@ get_temp_regvar (tree type, tree init) tree build_vec_init (tree base, tree maxindex, tree init, bool explicit_default_init_p, - int from_array) + int from_array, tsubst_flags_t complain) { tree rval; tree base2 = NULL_TREE; @@ -2737,14 +2790,16 @@ build_vec_init (tree base, tree maxindex, tree init, current_stmt_tree ()->stmts_are_full_exprs_p = 1; if (MAYBE_CLASS_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE) - finish_expr_stmt (build_aggr_init (baseref, elt, 0)); + finish_expr_stmt (build_aggr_init (baseref, elt, 0, complain)); else - finish_expr_stmt (build_modify_expr (baseref, NOP_EXPR, - elt)); + finish_expr_stmt (cp_build_modify_expr (baseref, NOP_EXPR, + elt, complain)); current_stmt_tree ()->stmts_are_full_exprs_p = 0; - finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0)); - finish_expr_stmt (build_unary_op (PREDECREMENT_EXPR, iterator, 0)); + finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0, + complain)); + finish_expr_stmt (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0, + complain)); } /* Clear out INIT so that we don't get confused below. */ @@ -2766,7 +2821,8 @@ build_vec_init (tree base, tree maxindex, tree init, && TYPE_NEEDS_CONSTRUCTING (type) && ! TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) { - error ("initializer ends prematurely"); + if (complain & tf_error) + error ("initializer ends prematurely"); return error_mark_node; } } @@ -2794,7 +2850,8 @@ build_vec_init (tree base, tree maxindex, tree init, finish_for_cond (build2 (NE_EXPR, boolean_type_node, iterator, build_int_cst (TREE_TYPE (iterator), -1)), for_stmt); - finish_for_expr (build_unary_op (PREDECREMENT_EXPR, iterator, 0), + finish_for_expr (cp_build_unary_op (PREDECREMENT_EXPR, iterator, 0, + complain), for_stmt); to = build1 (INDIRECT_REF, type, base); @@ -2809,11 +2866,13 @@ build_vec_init (tree base, tree maxindex, tree init, from = NULL_TREE; if (from_array == 2) - elt_init = build_modify_expr (to, NOP_EXPR, from); + elt_init = cp_build_modify_expr (to, NOP_EXPR, from, + complain); else if (TYPE_NEEDS_CONSTRUCTING (type)) - elt_init = build_aggr_init (to, from, 0); + elt_init = build_aggr_init (to, from, 0, complain); else if (from) - elt_init = build_modify_expr (to, NOP_EXPR, from); + elt_init = cp_build_modify_expr (to, NOP_EXPR, from, + complain); else gcc_unreachable (); } @@ -2825,23 +2884,26 @@ build_vec_init (tree base, tree maxindex, tree init, elt_init = build_vec_init (build1 (INDIRECT_REF, type, base), 0, 0, /*explicit_default_init_p=*/false, - 0); + 0, complain); } else if (!TYPE_NEEDS_CONSTRUCTING (type)) - elt_init = (build_modify_expr + elt_init = (cp_build_modify_expr (to, INIT_EXPR, build_zero_init (type, size_one_node, - /*static_storage_p=*/false))); + /*static_storage_p=*/false), + complain)); else - elt_init = build_aggr_init (to, init, 0); + elt_init = build_aggr_init (to, init, 0, complain); current_stmt_tree ()->stmts_are_full_exprs_p = 1; finish_expr_stmt (elt_init); current_stmt_tree ()->stmts_are_full_exprs_p = 0; - finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base, 0)); + finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base, 0, + complain)); if (base2) - finish_expr_stmt (build_unary_op (PREINCREMENT_EXPR, base2, 0)); + finish_expr_stmt (cp_build_unary_op (PREINCREMENT_EXPR, base2, 0, + complain)); finish_for_stmt (for_stmt); } @@ -2851,13 +2913,15 @@ build_vec_init (tree base, tree maxindex, tree init, && from_array != 2) { tree e; - tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator); + tree m = cp_build_binary_op (MINUS_EXPR, maxindex, iterator, + complain); /* Flatten multi-dimensional array since build_vec_delete only expects one-dimensional array. */ if (TREE_CODE (type) == ARRAY_TYPE) m = cp_build_binary_op (MULT_EXPR, m, - array_type_nelts_total (type)); + array_type_nelts_total (type), + complain); finish_cleanup_try_block (try_block); e = build_vec_delete_1 (rval, m, @@ -2875,7 +2939,7 @@ build_vec_init (tree base, tree maxindex, tree init, /* Now convert make the result have the correct type. */ atype = build_pointer_type (atype); stmt_expr = build1 (NOP_EXPR, atype, stmt_expr); - stmt_expr = build_indirect_ref (stmt_expr, NULL); + stmt_expr = cp_build_indirect_ref (stmt_expr, NULL, complain); current_stmt_tree ()->stmts_are_full_exprs_p = destroy_temps; return stmt_expr; @@ -2911,7 +2975,8 @@ build_dtor_call (tree exp, special_function_kind dtor_kind, int flags) /*args=*/NULL_TREE, /*conversion_path=*/NULL_TREE, flags, - /*fn_p=*/NULL); + /*fn_p=*/NULL, + tf_warning_or_error); } /* Generate a call to a destructor. TYPE is the type to cast ADDR to. @@ -2993,7 +3058,7 @@ build_delete (tree type, tree addr, special_function_kind auto_delete, /* Don't check PROTECT here; leave that decision to the destructor. If the destructor is accessible, call it, else report error. */ - addr = build_unary_op (ADDR_EXPR, addr, 0); + addr = cp_build_unary_op (ADDR_EXPR, addr, 0, tf_warning_or_error); if (TREE_SIDE_EFFECTS (addr)) addr = save_expr (addr); @@ -3065,7 +3130,8 @@ build_delete (tree type, tree addr, special_function_kind auto_delete, /*alloc_fn=*/NULL_TREE); } - expr = build_dtor_call (build_indirect_ref (addr, NULL), + expr = build_dtor_call (cp_build_indirect_ref (addr, NULL, + tf_warning_or_error), auto_delete, flags); if (do_delete) expr = build2 (COMPOUND_EXPR, void_type_node, expr, do_delete); @@ -3079,7 +3145,8 @@ build_delete (tree type, tree addr, special_function_kind auto_delete, ifexp = integer_one_node; else /* Handle deleting a null pointer. */ - ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node)); + ifexp = fold (cp_build_binary_op (NE_EXPR, addr, integer_zero_node, + tf_warning_or_error)); if (ifexp != integer_one_node) expr = build3 (COND_EXPR, void_type_node, @@ -3123,7 +3190,8 @@ push_base_cleanups (void) NULL_TREE, base_binfo, (LOOKUP_NORMAL - | LOOKUP_NONVIRTUAL)); + | LOOKUP_NONVIRTUAL), + tf_warning_or_error); expr = build3 (COND_EXPR, void_type_node, cond, expr, void_zero_node); finish_decl_cleanup (NULL_TREE, expr); @@ -3142,7 +3210,8 @@ push_base_cleanups (void) expr = build_special_member_call (current_class_ref, base_dtor_identifier, NULL_TREE, base_binfo, - LOOKUP_NORMAL | LOOKUP_NONVIRTUAL); + LOOKUP_NORMAL | LOOKUP_NONVIRTUAL, + tf_warning_or_error); finish_decl_cleanup (NULL_TREE, expr); } @@ -3158,7 +3227,8 @@ push_base_cleanups (void) tree this_member = (build_class_member_access_expr (current_class_ref, member, /*access_path=*/NULL_TREE, - /*preserve_reference=*/false)); + /*preserve_reference=*/false, + tf_warning_or_error)); tree this_type = TREE_TYPE (member); expr = build_delete (this_type, this_member, sfk_complete_destructor, @@ -3211,7 +3281,7 @@ build_vec_delete (tree base, tree maxindex, build_pointer_type (sizetype), base, cookie_addr); - maxindex = build_indirect_ref (cookie_addr, NULL); + maxindex = cp_build_indirect_ref (cookie_addr, NULL, tf_warning_or_error); } else if (TREE_CODE (type) == ARRAY_TYPE) { @@ -3219,7 +3289,7 @@ build_vec_delete (tree base, tree maxindex, bad name. */ maxindex = array_type_nelts_total (type); type = strip_array_types (type); - base = build_unary_op (ADDR_EXPR, base, 1); + base = cp_build_unary_op (ADDR_EXPR, base, 1, tf_warning_or_error); if (TREE_SIDE_EFFECTS (base)) { base_init = get_target_expr (base); diff --git a/gcc/cp/method.c b/gcc/cp/method.c index c8061bbc6b8..5d50f8542f9 100644 --- a/gcc/cp/method.c +++ b/gcc/cp/method.c @@ -674,7 +674,8 @@ do_build_assign_ref (tree fndecl) build_tree_list (NULL_TREE, converted_parm), base_binfo, - LOOKUP_NORMAL | LOOKUP_NONVIRTUAL)); + LOOKUP_NORMAL | LOOKUP_NONVIRTUAL, + tf_warning_or_error)); } /* Assign to each of the non-static data members. */ @@ -729,7 +730,8 @@ do_build_assign_ref (tree fndecl) init = build3 (COMPONENT_REF, expr_type, init, field, NULL_TREE); if (DECL_NAME (field)) - init = build_modify_expr (comp, NOP_EXPR, init); + init = cp_build_modify_expr (comp, NOP_EXPR, init, + tf_warning_or_error); else init = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, init); finish_expr_stmt (init); diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 8156822f626..8a9c3e29563 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -4333,19 +4333,20 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, { case RID_DYNCAST: postfix_expression - = build_dynamic_cast (type, expression); + = build_dynamic_cast (type, expression, tf_warning_or_error); break; case RID_STATCAST: postfix_expression - = build_static_cast (type, expression); + = build_static_cast (type, expression, tf_warning_or_error); break; case RID_REINTCAST: postfix_expression - = build_reinterpret_cast (type, expression); + = build_reinterpret_cast (type, expression, + tf_warning_or_error); break; case RID_CONSTCAST: postfix_expression - = build_const_cast (type, expression); + = build_const_cast (type, expression, tf_warning_or_error); break; default: gcc_unreachable (); @@ -4644,12 +4645,14 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, (instance, fn, args, NULL_TREE, (idk == CP_ID_KIND_QUALIFIED ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL), - /*fn_p=*/NULL)); + /*fn_p=*/NULL, + tf_warning_or_error)); else postfix_expression = finish_call_expr (postfix_expression, args, /*disallow_virtual=*/false, - /*koenig_p=*/false); + /*koenig_p=*/false, + tf_warning_or_error); } else if (TREE_CODE (postfix_expression) == OFFSET_REF || TREE_CODE (postfix_expression) == MEMBER_REF @@ -4662,13 +4665,15 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p, postfix_expression = finish_call_expr (postfix_expression, args, /*disallow_virtual=*/true, - koenig_p); + koenig_p, + tf_warning_or_error); else /* All other function calls. */ postfix_expression = finish_call_expr (postfix_expression, args, /*disallow_virtual=*/false, - koenig_p); + koenig_p, + tf_warning_or_error); /* The POSTFIX_EXPRESSION is certainly no longer an id. */ idk = CP_ID_KIND_NONE; @@ -4937,7 +4942,8 @@ cp_parser_postfix_dot_deref_expression (cp_parser *parser, (name, BINFO_TYPE (BASELINK_ACCESS_BINFO (name)), scope); postfix_expression = finish_class_member_access_expr (postfix_expression, name, - template_p); + template_p, + tf_warning_or_error); } } @@ -5250,7 +5256,7 @@ cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p) if (TYPE_P (operand)) return cxx_sizeof_or_alignof_type (operand, op, true); else - return cxx_sizeof_or_alignof_expr (operand, op); + return cxx_sizeof_or_alignof_expr (operand, op, true); } case RID_NEW: @@ -5287,7 +5293,8 @@ cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p) /* Create the complete representation. */ return build_x_unary_op ((keyword == RID_REALPART ? REALPART_EXPR : IMAGPART_EXPR), - expression); + expression, + tf_warning_or_error); } break; @@ -5362,14 +5369,16 @@ cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p) { case INDIRECT_REF: non_constant_p = "`*'"; - expression = build_x_indirect_ref (cast_expression, "unary *"); + expression = build_x_indirect_ref (cast_expression, "unary *", + tf_warning_or_error); break; case ADDR_EXPR: non_constant_p = "`&'"; /* Fall through. */ case BIT_NOT_EXPR: - expression = build_x_unary_op (unary_operator, cast_expression); + expression = build_x_unary_op (unary_operator, cast_expression, + tf_warning_or_error); break; case PREINCREMENT_EXPR: @@ -5500,7 +5509,8 @@ cp_parser_new_expression (cp_parser* parser) return error_mark_node; /* Create a representation of the new-expression. */ - return build_new (placement, type, nelts, initializer, global_scope_p); + return build_new (placement, type, nelts, initializer, global_scope_p, + tf_warning_or_error); } /* Parse a new-placement. @@ -5870,7 +5880,7 @@ cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p) return error_mark_node; /* Perform the cast. */ - expr = build_c_cast (type, expr); + expr = build_c_cast (type, expr, tf_warning_or_error); return expr; } } @@ -6059,7 +6069,7 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p) overloaded_p = false; lhs = build_x_binary_op (tree_type, lhs, lhs_type, rhs, rhs_type, - &overloaded_p); + &overloaded_p, tf_warning_or_error); lhs_type = tree_type; /* If the binary operator required the use of an overloaded operator, @@ -6115,7 +6125,8 @@ cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr) /* Build the conditional-expression. */ return build_x_conditional_expr (logical_or_expr, expr, - assignment_expr); + assignment_expr, + tf_warning_or_error); } /* Parse an assignment-expression. @@ -6170,7 +6181,8 @@ cp_parser_assignment_expression (cp_parser* parser, bool cast_p) /* Build the assignment expression. */ expr = build_x_modify_expr (expr, assignment_operator, - rhs); + rhs, + tf_warning_or_error); } } } @@ -6290,7 +6302,8 @@ cp_parser_expression (cp_parser* parser, bool cast_p) expression = assignment_expression; else expression = build_x_compound_expr (expression, - assignment_expression); + assignment_expression, + tf_warning_or_error); /* If the next token is not a comma, then we are done with the expression. */ if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)) @@ -6410,7 +6423,8 @@ cp_parser_builtin_offsetof (cp_parser *parser) cp_parser_require (parser, CPP_COMMA, "`,'"); /* Build the (type *)null that begins the traditional offsetof macro. */ - expr = build_static_cast (build_pointer_type (type), null_pointer_node); + expr = build_static_cast (build_pointer_type (type), null_pointer_node, + tf_warning_or_error); /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */ expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, expr, @@ -10320,7 +10334,8 @@ cp_parser_template_argument (cp_parser* parser) if (cp_parser_parse_definitely (parser)) { if (address_p) - argument = build_x_unary_op (ADDR_EXPR, argument); + argument = build_x_unary_op (ADDR_EXPR, argument, + tf_warning_or_error); return argument; } } @@ -17181,7 +17196,8 @@ cp_parser_functional_cast (cp_parser* parser, tree type) /*allow_expansion_p=*/true, /*non_constant_p=*/NULL); - cast = build_functional_cast (type, expression_list); + cast = build_functional_cast (type, expression_list, + tf_warning_or_error); /* [expr.const]/1: In an integral constant expression "only type conversions to integral or enumeration type can be used". */ if (TREE_CODE (type) == TYPE_DECL) diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 628a445a58e..bc33efc7fbd 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -10684,7 +10684,7 @@ tsubst_copy_and_build (tree t, r = convert_from_reference (r); } else - r = build_x_indirect_ref (r, "unary *"); + r = build_x_indirect_ref (r, "unary *", complain); return r; } @@ -10706,8 +10706,9 @@ tsubst_copy_and_build (tree t, if (integral_constant_expression_p && !cast_valid_in_integral_constant_expression_p (type)) { - error ("a cast to a type other than an integral or " - "enumeration type cannot appear in a constant-expression"); + if (complain & tf_error) + error ("a cast to a type other than an integral or " + "enumeration type cannot appear in a constant-expression"); return error_mark_node; } @@ -10716,15 +10717,15 @@ tsubst_copy_and_build (tree t, switch (TREE_CODE (t)) { case CAST_EXPR: - return build_functional_cast (type, op); + return build_functional_cast (type, op, complain); case REINTERPRET_CAST_EXPR: - return build_reinterpret_cast (type, op); + return build_reinterpret_cast (type, op, complain); case CONST_CAST_EXPR: - return build_const_cast (type, op); + return build_const_cast (type, op, complain); case DYNAMIC_CAST_EXPR: - return build_dynamic_cast (type, op); + return build_dynamic_cast (type, op, complain); case STATIC_CAST_EXPR: - return build_static_cast (type, op); + return build_static_cast (type, op, complain); default: gcc_unreachable (); } @@ -10734,7 +10735,7 @@ tsubst_copy_and_build (tree t, case POSTINCREMENT_EXPR: op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0), args, complain, in_decl); - return build_x_unary_op (TREE_CODE (t), op1); + return build_x_unary_op (TREE_CODE (t), op1, complain); case PREDECREMENT_EXPR: case PREINCREMENT_EXPR: @@ -10745,7 +10746,8 @@ tsubst_copy_and_build (tree t, case UNARY_PLUS_EXPR: /* Unary + */ case REALPART_EXPR: case IMAGPART_EXPR: - return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0))); + return build_x_unary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)), + complain); case ADDR_EXPR: op1 = TREE_OPERAND (t, 0); @@ -10757,7 +10759,7 @@ tsubst_copy_and_build (tree t, in_decl); if (TREE_CODE (op1) == LABEL_DECL) return finish_label_address_expr (DECL_NAME (op1)); - return build_x_unary_op (ADDR_EXPR, op1); + return build_x_unary_op (ADDR_EXPR, op1, complain); case PLUS_EXPR: case MINUS_EXPR: @@ -10800,7 +10802,8 @@ tsubst_copy_and_build (tree t, (TREE_NO_WARNING (TREE_OPERAND (t, 1)) ? ERROR_MARK : TREE_CODE (TREE_OPERAND (t, 1))), - /*overloaded_p=*/NULL); + /*overloaded_p=*/NULL, + complain); case SCOPE_REF: return tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true, @@ -10816,7 +10819,8 @@ tsubst_copy_and_build (tree t, (TREE_NO_WARNING (TREE_OPERAND (t, 1)) ? ERROR_MARK : TREE_CODE (TREE_OPERAND (t, 1))), - /*overloaded_p=*/NULL); + /*overloaded_p=*/NULL, + complain); case SIZEOF_EXPR: if (PACK_EXPANSION_P (TREE_OPERAND (t, 0))) @@ -10849,16 +10853,19 @@ tsubst_copy_and_build (tree t, --skip_evaluation; } if (TYPE_P (op1)) - return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), true); + return cxx_sizeof_or_alignof_type (op1, TREE_CODE (t), + complain & tf_error); else - return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t)); + return cxx_sizeof_or_alignof_expr (op1, TREE_CODE (t), + complain & tf_error); case MODOP_EXPR: { tree r = build_x_modify_expr (RECUR (TREE_OPERAND (t, 0)), TREE_CODE (TREE_OPERAND (t, 1)), - RECUR (TREE_OPERAND (t, 2))); + RECUR (TREE_OPERAND (t, 2)), + complain); /* TREE_NO_WARNING must be set if either the expression was parenthesized or it uses an operator such as >>= rather than plain assignment. In the former case, it was already @@ -10896,7 +10903,8 @@ tsubst_copy_and_build (tree t, RECUR (TREE_OPERAND (t, 1)), RECUR (TREE_OPERAND (t, 2)), init, - NEW_EXPR_USE_GLOBAL (t)); + NEW_EXPR_USE_GLOBAL (t), + complain); } case DELETE_EXPR: @@ -10908,7 +10916,8 @@ tsubst_copy_and_build (tree t, case COMPOUND_EXPR: return build_x_compound_expr (RECUR (TREE_OPERAND (t, 0)), - RECUR (TREE_OPERAND (t, 1))); + RECUR (TREE_OPERAND (t, 1)), + complain); case CALL_EXPR: { @@ -10982,25 +10991,29 @@ tsubst_copy_and_build (tree t, if (!BASELINK_P (TREE_OPERAND (function, 1))) return finish_call_expr (function, call_args, /*disallow_virtual=*/false, - /*koenig_p=*/false); + /*koenig_p=*/false, + complain); else return (build_new_method_call (TREE_OPERAND (function, 0), TREE_OPERAND (function, 1), call_args, NULL_TREE, qualified_p ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL, - /*fn_p=*/NULL)); + /*fn_p=*/NULL, + complain)); } return finish_call_expr (function, call_args, /*disallow_virtual=*/qualified_p, - koenig_p); + koenig_p, + complain); } case COND_EXPR: return build_x_conditional_expr (RECUR (TREE_OPERAND (t, 0)), RECUR (TREE_OPERAND (t, 1)), - RECUR (TREE_OPERAND (t, 2))); + RECUR (TREE_OPERAND (t, 2)), + complain); case PSEUDO_DTOR_EXPR: return finish_pseudo_destructor_expr @@ -11184,7 +11197,8 @@ tsubst_copy_and_build (tree t, return finish_non_static_data_member (member, object, NULL_TREE); return finish_class_member_access_expr (object, member, - /*template_p=*/false); + /*template_p=*/false, + complain); } case THROW_EXPR: diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c index 8bd51c80a20..d17ef6433e1 100644 --- a/gcc/cp/rtti.c +++ b/gcc/cp/rtti.c @@ -104,7 +104,7 @@ static GTY (()) VEC(tinfo_s,gc) *tinfo_descs; static tree ifnonnull (tree, tree); static tree tinfo_name (tree); -static tree build_dynamic_cast_1 (tree, tree); +static tree build_dynamic_cast_1 (tree, tree, tsubst_flags_t); static tree throw_bad_cast (void); static tree throw_bad_typeid (void); static tree get_tinfo_decl_dynamic (tree); @@ -188,7 +188,9 @@ build_headof (tree exp) index = build_int_cst (NULL_TREE, -2 * TARGET_VTABLE_DATA_ENTRY_DISTANCE); - offset = build_vtbl_ref (build_indirect_ref (exp, NULL), index); + offset = build_vtbl_ref (cp_build_indirect_ref (exp, NULL, + tf_warning_or_error), + index); type = build_qualified_type (ptr_type_node, cp_type_quals (TREE_TYPE (exp))); @@ -272,7 +274,7 @@ get_tinfo_decl_dynamic (tree exp) /* Otherwise return the type_info for the static type of the expr. */ t = get_tinfo_ptr (TYPE_MAIN_VARIANT (type)); - return build_indirect_ref (t, NULL); + return cp_build_indirect_ref (t, NULL, tf_warning_or_error); } static bool @@ -463,7 +465,8 @@ get_typeid (tree type) if (!type) return error_mark_node; - return build_indirect_ref (get_tinfo_ptr (type), NULL); + return cp_build_indirect_ref (get_tinfo_ptr (type), NULL, + tf_warning_or_error); } /* Check whether TEST is null before returning RESULT. If TEST is used in @@ -483,7 +486,7 @@ ifnonnull (tree test, tree result) paper. */ static tree -build_dynamic_cast_1 (tree type, tree expr) +build_dynamic_cast_1 (tree type, tree expr, tsubst_flags_t complain) { enum tree_code tc = TREE_CODE (type); tree exprtype = TREE_TYPE (expr); @@ -626,8 +629,9 @@ build_dynamic_cast_1 (tree type, tree expr) && TREE_CODE (TREE_TYPE (old_expr)) == RECORD_TYPE) { tree expr = throw_bad_cast (); - warning (0, "dynamic_cast of %q#D to %q#T can never succeed", - old_expr, type); + if (complain & tf_warning) + warning (0, "dynamic_cast of %q#D to %q#T can never succeed", + old_expr, type); /* Bash it to the expected type. */ TREE_TYPE (expr) = type; return expr; @@ -640,8 +644,9 @@ build_dynamic_cast_1 (tree type, tree expr) if (TREE_CODE (op) == VAR_DECL && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE) { - warning (0, "dynamic_cast of %q#D to %q#T can never succeed", - op, type); + if (complain & tf_warning) + warning (0, "dynamic_cast of %q#D to %q#T can never succeed", + op, type); retval = build_int_cst (type, 0); return retval; } @@ -650,7 +655,8 @@ build_dynamic_cast_1 (tree type, tree expr) /* Use of dynamic_cast when -fno-rtti is prohibited. */ if (!flag_rtti) { - error ("% not permitted with -fno-rtti"); + if (complain & tf_error) + error ("% not permitted with -fno-rtti"); return error_mark_node; } @@ -658,10 +664,10 @@ build_dynamic_cast_1 (tree type, tree expr) static_type = TYPE_MAIN_VARIANT (TREE_TYPE (exprtype)); td2 = get_tinfo_decl (target_type); mark_used (td2); - td2 = build_unary_op (ADDR_EXPR, td2, 0); + td2 = cp_build_unary_op (ADDR_EXPR, td2, 0, complain); td3 = get_tinfo_decl (static_type); mark_used (td3); - td3 = build_unary_op (ADDR_EXPR, td3, 0); + td3 = cp_build_unary_op (ADDR_EXPR, td3, 0, complain); /* Determine how T and V are related. */ boff = dcast_base_hint (static_type, target_type); @@ -671,7 +677,7 @@ build_dynamic_cast_1 (tree type, tree expr) expr1 = expr; if (tc == REFERENCE_TYPE) - expr1 = build_unary_op (ADDR_EXPR, expr1, 0); + expr1 = cp_build_unary_op (ADDR_EXPR, expr1, 0, complain); elems[0] = expr1; elems[1] = td3; @@ -726,13 +732,14 @@ build_dynamic_cast_1 (tree type, tree expr) errstr = "source type is not polymorphic"; fail: - error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)", - expr, exprtype, type, errstr); + if (complain & tf_error) + error ("cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)", + expr, exprtype, type, errstr); return error_mark_node; } tree -build_dynamic_cast (tree type, tree expr) +build_dynamic_cast (tree type, tree expr, tsubst_flags_t complain) { if (type == error_mark_node || expr == error_mark_node) return error_mark_node; @@ -744,7 +751,7 @@ build_dynamic_cast (tree type, tree expr) return convert_from_reference (expr); } - return convert_from_reference (build_dynamic_cast_1 (type, expr)); + return convert_from_reference (build_dynamic_cast_1 (type, expr, complain)); } /* Return the runtime bit mask encoding the qualifiers of TYPE. */ @@ -876,7 +883,8 @@ tinfo_base_init (tinfo_s *ti, tree target) } vtable_ptr = get_vtable_decl (real_type, /*complete=*/1); - vtable_ptr = build_unary_op (ADDR_EXPR, vtable_ptr, 0); + vtable_ptr = cp_build_unary_op (ADDR_EXPR, vtable_ptr, 0, + tf_warning_or_error); /* We need to point into the middle of the vtable. */ vtable_ptr = build2 diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index 74d9ae55af2..8966bf5d921 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -536,7 +536,7 @@ simplify_loop_decl_cond (tree *cond_p, tree body) *cond_p = boolean_true_node; if_stmt = begin_if_stmt (); - cond = build_unary_op (TRUTH_NOT_EXPR, cond, 0); + cond = cp_build_unary_op (TRUTH_NOT_EXPR, cond, 0, tf_warning_or_error); finish_if_stmt_cond (cond, if_stmt); finish_break_stmt (); finish_then_clause (if_stmt); @@ -614,10 +614,11 @@ finish_expr_stmt (tree expr) { if (warn_sequence_point) verify_sequence_points (expr); - expr = convert_to_void (expr, "statement"); + expr = convert_to_void (expr, "statement", tf_warning_or_error); } else if (!type_dependent_expression_p (expr)) - convert_to_void (build_non_dependent_expr (expr), "statement"); + convert_to_void (build_non_dependent_expr (expr), "statement", + tf_warning_or_error); if (check_for_bare_parameter_packs (expr)) expr = error_mark_node; @@ -872,10 +873,12 @@ finish_for_expr (tree expr, tree for_stmt) { if (warn_sequence_point) verify_sequence_points (expr); - expr = convert_to_void (expr, "3rd expression in for"); + expr = convert_to_void (expr, "3rd expression in for", + tf_warning_or_error); } else if (!type_dependent_expression_p (expr)) - convert_to_void (build_non_dependent_expr (expr), "3rd expression in for"); + convert_to_void (build_non_dependent_expr (expr), "3rd expression in for", + tf_warning_or_error); expr = maybe_cleanup_point_expr_void (expr); if (check_for_bare_parameter_packs (expr)) expr = error_mark_node; @@ -1247,7 +1250,7 @@ finish_asm_stmt (int volatile_p, tree string, tree output_operands, otherwise we'll get an error. Gross, but ... */ STRIP_NOPS (operand); - if (!lvalue_or_else (operand, lv_asm)) + if (!lvalue_or_else (operand, lv_asm, tf_warning_or_error)) operand = error_mark_node; if (operand != error_mark_node @@ -1505,7 +1508,8 @@ finish_non_static_data_member (tree decl, tree object, tree qualifying_scope) return build_class_member_access_expr (object, decl, /*access_path=*/NULL_TREE, - /*preserve_reference=*/false); + /*preserve_reference=*/false, + tf_warning_or_error); } } @@ -1643,7 +1647,8 @@ finish_qualified_id_expr (tree qualifying_class, (maybe_dummy_object (qualifying_class, NULL), expr, BASELINK_ACCESS_BINFO (expr), - /*preserve_reference=*/false)); + /*preserve_reference=*/false, + tf_warning_or_error)); else if (done) /* The expression is a qualified name whose address is not being taken. */ @@ -1832,7 +1837,8 @@ perform_koenig_lookup (tree fn, tree args) Returns code for the call. */ tree -finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p) +finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p, + tsubst_flags_t complain) { tree result; tree orig_fn; @@ -1931,7 +1937,8 @@ finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p) result = build_new_method_call (object, fn, args, NULL_TREE, (disallow_virtual ? LOOKUP_NONVIRTUAL : 0), - /*fn_p=*/NULL); + /*fn_p=*/NULL, + complain); } else if (is_overloaded_fn (fn)) { @@ -1943,7 +1950,7 @@ finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p) if (!result) /* A call to a namespace-scope function. */ - result = build_new_function_call (fn, args, koenig_p); + result = build_new_function_call (fn, args, koenig_p, complain); } else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR) { @@ -1960,11 +1967,11 @@ finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p) /* If the "function" is really an object of class type, it might have an overloaded `operator ()'. */ result = build_new_op (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE, - /*overloaded_p=*/NULL); + /*overloaded_p=*/NULL, complain); if (!result) /* A call where the function is unknown. */ - result = build_function_call (fn, args); + result = cp_build_function_call (fn, args, complain); if (processing_template_decl) { @@ -1981,7 +1988,7 @@ finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p) tree finish_increment_expr (tree expr, enum tree_code code) { - return build_x_unary_op (code, expr); + return build_x_unary_op (code, expr, tf_warning_or_error); } /* Finish a use of `this'. Returns an expression for `this'. */ @@ -2070,7 +2077,7 @@ finish_pseudo_destructor_expr (tree object, tree scope, tree destructor) tree finish_unary_op_expr (enum tree_code code, tree expr) { - tree result = build_x_unary_op (code, expr); + tree result = build_x_unary_op (code, expr, tf_warning_or_error); /* Inside a template, build_x_unary_op does not fold the expression. So check whether the result is folded before setting TREE_NEGATED_INT. */ @@ -2952,7 +2959,8 @@ finish_id_expression (tree id_expression, /* A set of member functions. */ decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0); return finish_class_member_access_expr (decl, id_expression, - /*template_p=*/false); + /*template_p=*/false, + tf_warning_or_error); } decl = baselink_for_fns (decl); @@ -3119,7 +3127,8 @@ simplify_aggr_init_expr (tree *tp) SLOT. */ push_deferring_access_checks (dk_no_check); call_expr = build_aggr_init (slot, call_expr, - DIRECT_BIND | LOOKUP_ONLYCONVERTING); + DIRECT_BIND | LOOKUP_ONLYCONVERTING, + tf_warning_or_error); pop_deferring_access_checks (); call_expr = build2 (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot); } @@ -3668,7 +3677,8 @@ finish_omp_clauses (tree clauses) } t = build_special_member_call (NULL_TREE, complete_ctor_identifier, - t, inner_type, LOOKUP_NORMAL); + t, inner_type, LOOKUP_NORMAL, + tf_warning_or_error); if (targetm.cxx.cdtor_returns_this () || errorcount) /* Because constructors and destructors return this, @@ -3690,7 +3700,8 @@ finish_omp_clauses (tree clauses) t = build_int_cst (build_pointer_type (inner_type), 0); t = build1 (INDIRECT_REF, inner_type, t); t = build_special_member_call (t, complete_dtor_identifier, - NULL, inner_type, LOOKUP_NORMAL); + NULL, inner_type, LOOKUP_NORMAL, + tf_warning_or_error); if (targetm.cxx.cdtor_returns_this () || errorcount) /* Because constructors and destructors return this, @@ -3713,7 +3724,8 @@ finish_omp_clauses (tree clauses) t = build1 (INDIRECT_REF, inner_type, t); t = build_special_member_call (t, ansi_assopname (NOP_EXPR), build_tree_list (NULL, t), - inner_type, LOOKUP_NORMAL); + inner_type, LOOKUP_NORMAL, + tf_warning_or_error); /* We'll have called convert_from_reference on the call, which may well have added an indirect_ref. It's unneeded here, @@ -3937,7 +3949,7 @@ finish_omp_for (location_t locus, tree decl, tree init, tree cond, if (!processing_template_decl) init = fold_build_cleanup_point_expr (TREE_TYPE (init), init); - init = build_modify_expr (decl, NOP_EXPR, init); + init = cp_build_modify_expr (decl, NOP_EXPR, init, tf_warning_or_error); if (cond && TREE_SIDE_EFFECTS (cond) && COMPARISON_CLASS_P (cond)) { int n = TREE_SIDE_EFFECTS (TREE_OPERAND (cond, 1)) != 0; @@ -4006,7 +4018,7 @@ void finish_omp_barrier (void) { tree fn = built_in_decls[BUILT_IN_GOMP_BARRIER]; - tree stmt = finish_call_expr (fn, NULL, false, false); + tree stmt = finish_call_expr (fn, NULL, false, false, tf_warning_or_error); finish_expr_stmt (stmt); } @@ -4014,7 +4026,7 @@ void finish_omp_flush (void) { tree fn = built_in_decls[BUILT_IN_SYNCHRONIZE]; - tree stmt = finish_call_expr (fn, NULL, false, false); + tree stmt = finish_call_expr (fn, NULL, false, false, tf_warning_or_error); finish_expr_stmt (stmt); } diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index 927b3de0dea..027f1c9b1f2 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -1992,7 +1992,7 @@ tree build_dummy_object (tree type) { tree decl = build1 (NOP_EXPR, build_pointer_type (type), void_zero_node); - return build_indirect_ref (decl, NULL); + return cp_build_indirect_ref (decl, NULL, tf_warning_or_error); } /* We've gotten a reference to a member of TYPE. Return *this if appropriate, @@ -2569,10 +2569,10 @@ stabilize_expr (tree exp, tree* initp) } else { - exp = build_unary_op (ADDR_EXPR, exp, 1); + exp = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error); init_expr = get_target_expr (exp); exp = TARGET_EXPR_SLOT (init_expr); - exp = build_indirect_ref (exp, 0); + exp = cp_build_indirect_ref (exp, 0, tf_warning_or_error); } *initp = init_expr; diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 036f93efecb..2e8151b1ff3 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -47,9 +47,11 @@ along with GCC; see the file COPYING3. If not see static tree pfn_from_ptrmemfunc (tree); static tree delta_from_ptrmemfunc (tree); -static tree convert_for_assignment (tree, tree, const char *, tree, int); +static tree convert_for_assignment (tree, tree, const char *, tree, int, + tsubst_flags_t); static tree cp_pointer_int_sum (enum tree_code, tree, tree); -static tree rationalize_conditional_expr (enum tree_code, tree); +static tree rationalize_conditional_expr (enum tree_code, tree, + tsubst_flags_t); static int comp_ptr_ttypes_real (tree, tree, int); static bool comp_except_types (tree, tree, bool); static bool comp_array_types (const_tree, const_tree, bool); @@ -59,7 +61,8 @@ static void casts_away_constness_r (tree *, tree *); static bool casts_away_constness (tree, tree); static void maybe_warn_about_returning_address_of_local (tree); static tree lookup_destructor (tree, tree, tree); -static int convert_arguments (int, tree *, tree, tree, tree, int); +static int convert_arguments (int, tree *, tree, tree, tree, int, + tsubst_flags_t); /* Do `exp = require_complete_type (exp);' to make sure exp does not have an incomplete type. (That includes void types.) @@ -394,7 +397,8 @@ type_after_usual_arithmetic_conversions (tree t1, tree t2) case. See that function for documentation fo the parameters. */ static tree -composite_pointer_type_r (tree t1, tree t2, const char* location) +composite_pointer_type_r (tree t1, tree t2, const char* location, + tsubst_flags_t complain) { tree pointee1; tree pointee2; @@ -426,12 +430,14 @@ composite_pointer_type_r (tree t1, tree t2, const char* location) && TREE_CODE (pointee2) == POINTER_TYPE) || (TYPE_PTR_TO_MEMBER_P (pointee1) && TYPE_PTR_TO_MEMBER_P (pointee2))) - result_type = composite_pointer_type_r (pointee1, pointee2, location); + result_type = composite_pointer_type_r (pointee1, pointee2, location, + complain); else { - pedwarn ("%s between distinct pointer types %qT and %qT " - "lacks a cast", - location, t1, t2); + if (complain & tf_error) + pedwarn ("%s between distinct pointer types %qT and %qT " + "lacks a cast", + location, t1, t2); result_type = void_type_node; } result_type = cp_build_qualified_type (result_type, @@ -442,7 +448,8 @@ composite_pointer_type_r (tree t1, tree t2, const char* location) if (TYPE_PTR_TO_MEMBER_P (t1)) { if (!same_type_p (TYPE_PTRMEM_CLASS_TYPE (t1), - TYPE_PTRMEM_CLASS_TYPE (t2))) + TYPE_PTRMEM_CLASS_TYPE (t2)) + && (complain & tf_error)) pedwarn ("%s between distinct pointer types %qT and %qT " "lacks a cast", location, t1, t2); @@ -466,7 +473,7 @@ composite_pointer_type_r (tree t1, tree t2, const char* location) tree composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2, - const char* location) + const char* location, tsubst_flags_t complain) { tree class1; tree class2; @@ -504,7 +511,7 @@ composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2, tree attributes; tree result_type; - if (pedantic && TYPE_PTRFN_P (t2)) + if (pedantic && TYPE_PTRFN_P (t2) && (complain & tf_error)) pedwarn ("ISO C++ forbids %s between pointer of type % " "and pointer-to-function", location); result_type @@ -543,8 +550,9 @@ composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2, (cp_build_qualified_type (class2, TYPE_QUALS (class1)))); else { - error ("%s between distinct pointer types %qT and %qT " - "lacks a cast", location, t1, t2); + if (complain & tf_error) + error ("%s between distinct pointer types %qT and %qT " + "lacks a cast", location, t1, t2); return error_mark_node; } } @@ -563,13 +571,14 @@ composite_pointer_type (tree t1, tree t2, tree arg1, tree arg2, t2 = build_ptrmem_type (class1, TYPE_PTRMEM_POINTED_TO_TYPE (t2)); else { - error ("%s between distinct pointer-to-member types %qT and %qT " - "lacks a cast", location, t1, t2); + if (complain & tf_error) + error ("%s between distinct pointer-to-member types %qT and %qT " + "lacks a cast", location, t1, t2); return error_mark_node; } } - return composite_pointer_type_r (t1, t2, location); + return composite_pointer_type_r (t1, t2, location, complain); } /* Return the merged type of two types. @@ -764,7 +773,7 @@ common_type (tree t1, tree t2) || (TYPE_PTRMEM_P (t1) && TYPE_PTRMEM_P (t2)) || (TYPE_PTRMEMFUNC_P (t1) && TYPE_PTRMEMFUNC_P (t2))) return composite_pointer_type (t1, t2, error_mark_node, error_mark_node, - "conversion"); + "conversion", tf_warning_or_error); else gcc_unreachable (); } @@ -1299,10 +1308,27 @@ cxx_sizeof_or_alignof_type (tree type, enum tree_code op, bool complain) complain); } +/* Return the size of the type, without producing any warnings for + types whose size cannot be taken. This routine should be used only + in some other routine that has already produced a diagnostic about + using the size of such a type. */ +tree +cxx_sizeof_nowarn (tree type) +{ + if (TREE_CODE (type) == FUNCTION_TYPE + || TREE_CODE (type) == VOID_TYPE + || TREE_CODE (type) == ERROR_MARK) + return size_one_node; + else if (!COMPLETE_TYPE_P (type)) + return size_zero_node; + else + return cxx_sizeof_or_alignof_type (type, SIZEOF_EXPR, false); +} + /* Process a sizeof expression where the operand is an expression. */ static tree -cxx_sizeof_expr (tree e) +cxx_sizeof_expr (tree e, tsubst_flags_t complain) { if (e == error_mark_node) return error_mark_node; @@ -1320,24 +1346,33 @@ cxx_sizeof_expr (tree e) && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1))) { - error ("invalid application of % to a bit-field"); + if (complain & tf_error) + error ("invalid application of % to a bit-field"); + else + return error_mark_node; e = char_type_node; } else if (is_overloaded_fn (e)) { - pedwarn ("ISO C++ forbids applying % to an expression of " - "function type"); + if (complain & tf_error) + pedwarn ("ISO C++ forbids applying % to an expression of " + "function type"); + else + return error_mark_node; e = char_type_node; } else if (type_unknown_p (e)) { - cxx_incomplete_type_error (e, TREE_TYPE (e)); + if (complain & tf_error) + cxx_incomplete_type_error (e, TREE_TYPE (e)); + else + return error_mark_node; e = char_type_node; } else e = TREE_TYPE (e); - return cxx_sizeof_or_alignof_type (e, SIZEOF_EXPR, true); + return cxx_sizeof_or_alignof_type (e, SIZEOF_EXPR, complain & tf_error); } /* Implement the __alignof keyword: Return the minimum required @@ -1346,7 +1381,7 @@ cxx_sizeof_expr (tree e) "aligned" __attribute__ specification). */ static tree -cxx_alignof_expr (tree e) +cxx_alignof_expr (tree e, tsubst_flags_t complain) { tree t; @@ -1368,7 +1403,10 @@ cxx_alignof_expr (tree e) && TREE_CODE (TREE_OPERAND (e, 1)) == FIELD_DECL && DECL_C_BIT_FIELD (TREE_OPERAND (e, 1))) { - error ("invalid application of %<__alignof%> to a bit-field"); + if (complain & tf_error) + error ("invalid application of %<__alignof%> to a bit-field"); + else + return error_mark_node; t = size_one_node; } else if (TREE_CODE (e) == COMPONENT_REF @@ -1376,8 +1414,11 @@ cxx_alignof_expr (tree e) t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (e, 1))); else if (is_overloaded_fn (e)) { - pedwarn ("ISO C++ forbids applying %<__alignof%> to an expression of " - "function type"); + if (complain & tf_error) + pedwarn ("ISO C++ forbids applying %<__alignof%> to an expression of " + "function type"); + else + return error_mark_node; if (TREE_CODE (e) == FUNCTION_DECL) t = size_int (DECL_ALIGN_UNIT (e)); else @@ -1385,11 +1426,15 @@ cxx_alignof_expr (tree e) } else if (type_unknown_p (e)) { - cxx_incomplete_type_error (e, TREE_TYPE (e)); + if (complain & tf_error) + cxx_incomplete_type_error (e, TREE_TYPE (e)); + else + return error_mark_node; t = size_one_node; } else - return cxx_sizeof_or_alignof_type (TREE_TYPE (e), ALIGNOF_EXPR, true); + return cxx_sizeof_or_alignof_type (TREE_TYPE (e), ALIGNOF_EXPR, + complain & tf_error); return fold_convert (size_type_node, t); } @@ -1398,12 +1443,12 @@ cxx_alignof_expr (tree e) is an expression. */ tree -cxx_sizeof_or_alignof_expr (tree e, enum tree_code op) +cxx_sizeof_or_alignof_expr (tree e, enum tree_code op, bool complain) { if (op == SIZEOF_EXPR) - return cxx_sizeof_expr (e); + return cxx_sizeof_expr (e, complain? tf_warning_or_error : tf_none); else - return cxx_alignof_expr (e); + return cxx_alignof_expr (e, complain? tf_warning_or_error : tf_none); } /* EXPR is being used in a context that is not a function call. @@ -1423,11 +1468,12 @@ cxx_sizeof_or_alignof_expr (tree e, enum tree_code op) violates these rules. */ bool -invalid_nonstatic_memfn_p (const_tree expr) +invalid_nonstatic_memfn_p (const_tree expr, tsubst_flags_t complain) { if (TREE_CODE (TREE_TYPE (expr)) == METHOD_TYPE) { - error ("invalid use of non-static member function"); + if (complain & tf_error) + error ("invalid use of non-static member function"); return true; } return false; @@ -1536,10 +1582,10 @@ decay_conversion (tree exp) error ("void value not ignored as it ought to be"); return error_mark_node; } - if (invalid_nonstatic_memfn_p (exp)) + if (invalid_nonstatic_memfn_p (exp, tf_warning_or_error)) return error_mark_node; if (code == FUNCTION_TYPE || is_overloaded_fn (exp)) - return build_unary_op (ADDR_EXPR, exp, 0); + return cp_build_unary_op (ADDR_EXPR, exp, 0, tf_warning_or_error); if (code == ARRAY_TYPE) { tree adr; @@ -1574,7 +1620,7 @@ decay_conversion (tree exp) } /* This way is better for a COMPONENT_REF since it can simplify the offset for a component. */ - adr = build_unary_op (ADDR_EXPR, exp, 1); + adr = cp_build_unary_op (ADDR_EXPR, exp, 1, tf_warning_or_error); return cp_convert (ptrtype, adr); } @@ -1715,7 +1761,8 @@ string_conv_p (const_tree totype, const_tree exp, int warn) get it there. */ static tree -rationalize_conditional_expr (enum tree_code code, tree t) +rationalize_conditional_expr (enum tree_code code, tree t, + tsubst_flags_t complain) { /* For MIN_EXPR or MAX_EXPR, fold-const.c has arranged things so that the first operand is always the one to be used if both operands @@ -1733,15 +1780,20 @@ rationalize_conditional_expr (enum tree_code code, tree t) ? LE_EXPR : GE_EXPR), op0, TREE_CODE (op0), op1, TREE_CODE (op1), - /*overloaded_p=*/NULL), - build_unary_op (code, op0, 0), - build_unary_op (code, op1, 0)); + /*overloaded_p=*/NULL, + complain), + cp_build_unary_op (code, op0, 0, complain), + cp_build_unary_op (code, op1, 0, complain), + complain); } return build_conditional_expr (TREE_OPERAND (t, 0), - build_unary_op (code, TREE_OPERAND (t, 1), 0), - build_unary_op (code, TREE_OPERAND (t, 2), 0)); + cp_build_unary_op (code, TREE_OPERAND (t, 1), 0, + complain), + cp_build_unary_op (code, TREE_OPERAND (t, 2), 0, + complain), + complain); } /* Given the TYPE of an anonymous union field inside T, return the @@ -1794,7 +1846,8 @@ lookup_anon_field (tree t, tree type) tree build_class_member_access_expr (tree object, tree member, - tree access_path, bool preserve_reference) + tree access_path, bool preserve_reference, + tsubst_flags_t complain) { tree object_type; tree member_scope; @@ -1815,8 +1868,9 @@ build_class_member_access_expr (tree object, tree member, return error_mark_node; if (!CLASS_TYPE_P (object_type)) { - error ("request for member %qD in %qE, which is of non-class type %qT", - member, object, object_type); + if (complain & tf_error) + error ("request for member %qD in %qE, which is of non-class type %qT", + member, object, object_type); return error_mark_node; } @@ -1841,10 +1895,13 @@ build_class_member_access_expr (tree object, tree member, member_scope = TYPE_CONTEXT (member_scope); if (!member_scope || !DERIVED_FROM_P (member_scope, object_type)) { - if (TREE_CODE (member) == FIELD_DECL) - error ("invalid use of nonstatic data member %qE", member); - else - error ("%qD is not a member of %qT", member, object_type); + if (complain & tf_error) + { + if (TREE_CODE (member) == FIELD_DECL) + error ("invalid use of nonstatic data member %qE", member); + else + error ("%qD is not a member of %qT", member, object_type); + } return error_mark_node; } @@ -1854,7 +1911,7 @@ build_class_member_access_expr (tree object, tree member, { tree temp = unary_complex_lvalue (ADDR_EXPR, object); if (temp) - object = build_indirect_ref (temp, NULL); + object = cp_build_indirect_ref (temp, NULL, complain); } /* In [expr.ref], there is an explicit list of the valid choices for @@ -1894,10 +1951,13 @@ build_class_member_access_expr (tree object, tree member, offsetof macro. */ if (null_object_p && kind == bk_via_virtual) { - error ("invalid access to non-static data member %qD of " - "NULL object", - member); - error ("(perhaps the % macro was used incorrectly)"); + if (complain & tf_error) + { + error ("invalid access to non-static data member %qD of " + "NULL object", + member); + error ("(perhaps the % macro was used incorrectly)"); + } return error_mark_node; } @@ -1920,7 +1980,8 @@ build_class_member_access_expr (tree object, tree member, if (null_object_p && warn_invalid_offsetof && CLASSTYPE_NON_POD_P (object_type) && !DECL_FIELD_IS_BASE (member) - && !skip_evaluation) + && !skip_evaluation + && (complain & tf_warning)) { warning (OPT_Winvalid_offsetof, "invalid access to non-static data member %qD " @@ -1950,7 +2011,8 @@ build_class_member_access_expr (tree object, tree member, object = build_class_member_access_expr (object, anonymous_union, /*access_path=*/NULL_TREE, - preserve_reference); + preserve_reference, + complain); } /* Compute the type of the field, as described in [expr.ref]. */ @@ -2011,7 +2073,8 @@ build_class_member_access_expr (tree object, tree member, } else { - error ("invalid use of %qD", member); + if (complain & tf_error) + error ("invalid use of %qD", member); return error_mark_node; } @@ -2117,7 +2180,8 @@ check_template_keyword (tree decl) be a template via the use of the "A::template B" syntax. */ tree -finish_class_member_access_expr (tree object, tree name, bool template_p) +finish_class_member_access_expr (tree object, tree name, bool template_p, + tsubst_flags_t complain) { tree expr; tree object_type; @@ -2165,8 +2229,9 @@ finish_class_member_access_expr (tree object, tree name, bool template_p) return error_mark_node; if (!CLASS_TYPE_P (object_type)) { - error ("request for member %qD in %qE, which is of non-class type %qT", - name, object, object_type); + if (complain & tf_error) + error ("request for member %qD in %qE, which is of non-class type %qT", + name, object, object_type); return error_mark_node; } @@ -2203,8 +2268,9 @@ finish_class_member_access_expr (tree object, tree name, bool template_p) name a member of OBJECT_TYPE. */ if (TREE_CODE (scope) == NAMESPACE_DECL) { - error ("%<%D::%D%> is not a member of %qT", - scope, name, object_type); + if (complain & tf_error) + error ("%<%D::%D%> is not a member of %qT", + scope, name, object_type); return error_mark_node; } @@ -2218,7 +2284,8 @@ finish_class_member_access_expr (tree object, tree name, bool template_p) return error_mark_node; if (!access_path) { - error ("%qT is not a base of %qT", scope, object_type); + if (complain & tf_error) + error ("%qT is not a base of %qT", scope, object_type); return error_mark_node; } } @@ -2237,7 +2304,8 @@ finish_class_member_access_expr (tree object, tree name, bool template_p) /*want_type=*/false); if (member == NULL_TREE) { - error ("%qD has no member named %qE", object_type, name); + if (complain & tf_error) + error ("%qD has no member named %qE", object_type, name); return error_mark_node; } if (member == error_mark_node) @@ -2252,7 +2320,8 @@ finish_class_member_access_expr (tree object, tree name, bool template_p) template = lookup_template_function (template, template_args); else { - error ("%qD is not a member template function", name); + if (complain & tf_error) + error ("%qD is not a member template function", name); return error_mark_node; } } @@ -2265,7 +2334,8 @@ finish_class_member_access_expr (tree object, tree name, bool template_p) check_template_keyword (member); expr = build_class_member_access_expr (object, member, access_path, - /*preserve_reference=*/false); + /*preserve_reference=*/false, + complain); if (processing_template_decl && expr != error_mark_node) { if (BASELINK_P (member)) @@ -2318,7 +2388,8 @@ build_ptrmemfunc_access_expr (tree ptrmem, tree member_name) Must also handle REFERENCE_TYPEs for C++. */ tree -build_x_indirect_ref (tree expr, const char *errorstring) +build_x_indirect_ref (tree expr, const char *errorstring, + tsubst_flags_t complain) { tree orig_expr = expr; tree rval; @@ -2331,9 +2402,9 @@ build_x_indirect_ref (tree expr, const char *errorstring) } rval = build_new_op (INDIRECT_REF, LOOKUP_NORMAL, expr, NULL_TREE, - NULL_TREE, /*overloaded_p=*/NULL); + NULL_TREE, /*overloaded_p=*/NULL, complain); if (!rval) - rval = build_indirect_ref (expr, errorstring); + rval = cp_build_indirect_ref (expr, errorstring, complain); if (processing_template_decl && rval != error_mark_node) return build_min_non_dep (INDIRECT_REF, rval, orig_expr); @@ -2341,8 +2412,16 @@ build_x_indirect_ref (tree expr, const char *errorstring) return rval; } +/* Helper function called from c-common. */ tree build_indirect_ref (tree ptr, const char *errorstring) +{ + return cp_build_indirect_ref (ptr, errorstring, tf_warning_or_error); +} + +tree +cp_build_indirect_ref (tree ptr, const char *errorstring, + tsubst_flags_t complain) { tree pointer, type; @@ -2385,7 +2464,8 @@ build_indirect_ref (tree ptr, const char *errorstring) { /* A pointer to incomplete type (other than cv void) can be dereferenced [expr.unary.op]/1 */ - error ("%qT is not a pointer-to-object type", type); + if (complain & tf_error) + error ("%qT is not a pointer-to-object type", type); return error_mark_node; } else if (TREE_CODE (pointer) == ADDR_EXPR @@ -2407,6 +2487,9 @@ build_indirect_ref (tree ptr, const char *errorstring) return ref; } } + else if (!(complain & tf_error)) + /* Don't emit any errors; we'll just return ERROR_MARK_NODE later. */ + ; /* `pointer' won't be an error_mark_node if we were given a pointer to member, so it's cool to check for this here. */ else if (TYPE_PTR_TO_MEMBER_P (type)) @@ -2462,7 +2545,8 @@ build_array_ref (tree array, tree idx) return build_conditional_expr (TREE_OPERAND (array, 0), build_array_ref (TREE_OPERAND (array, 1), idx), - build_array_ref (TREE_OPERAND (array, 2), idx)); + build_array_ref (TREE_OPERAND (array, 2), idx), + tf_warning_or_error); default: break; @@ -2568,8 +2652,10 @@ build_array_ref (tree array, tree idx) warn_array_subscript_with_type_char (idx); - return build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind), - "array indexing"); + return cp_build_indirect_ref (cp_build_binary_op (PLUS_EXPR, ar, ind, + tf_warning_or_error), + "array indexing", + tf_warning_or_error); } } @@ -2627,13 +2713,17 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function) switch (TARGET_PTRMEMFUNC_VBIT_LOCATION) { case ptrmemfunc_vbit_in_pfn: - e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node); - idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node); + e1 = cp_build_binary_op (BIT_AND_EXPR, idx, integer_one_node, + tf_warning_or_error); + idx = cp_build_binary_op (MINUS_EXPR, idx, integer_one_node, + tf_warning_or_error); break; case ptrmemfunc_vbit_in_delta: - e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node); - delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node); + e1 = cp_build_binary_op (BIT_AND_EXPR, delta, integer_one_node, + tf_warning_or_error); + delta = cp_build_binary_op (RSHIFT_EXPR, delta, integer_one_node, + tf_warning_or_error); break; default: @@ -2667,12 +2757,12 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function) /* Next extract the vtable pointer from the object. */ vtbl = build1 (NOP_EXPR, build_pointer_type (vtbl_ptr_type_node), instance_ptr); - vtbl = build_indirect_ref (vtbl, NULL); + vtbl = cp_build_indirect_ref (vtbl, NULL, tf_warning_or_error); /* Finally, extract the function pointer from the vtable. */ e2 = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (vtbl), vtbl, fold_convert (sizetype, idx)); - e2 = build_indirect_ref (e2, NULL); + e2 = cp_build_indirect_ref (e2, NULL, tf_warning_or_error); TREE_CONSTANT (e2) = 1; TREE_INVARIANT (e2) = 1; @@ -2680,10 +2770,11 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function) vtable entry is treated as a function pointer. */ if (TARGET_VTABLE_USES_DESCRIPTORS) e2 = build1 (NOP_EXPR, TREE_TYPE (e2), - build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1)); + cp_build_unary_op (ADDR_EXPR, e2, /*noconvert=*/1, + tf_warning_or_error)); e2 = fold_convert (TREE_TYPE (e3), e2); - e1 = build_conditional_expr (e1, e2, e3); + e1 = build_conditional_expr (e1, e2, e3, tf_warning_or_error); /* Make sure this doesn't get evaluated first inside one of the branches of the COND_EXPR. */ @@ -2696,8 +2787,15 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function) return function; } +/* Used by the C-common bits. */ tree build_function_call (tree function, tree params) +{ + return cp_build_function_call (function, params, tf_warning_or_error); +} + +tree +cp_build_function_call (tree function, tree params, tsubst_flags_t complain) { tree fntype, fndecl; tree name = NULL_TREE; @@ -2725,7 +2823,7 @@ build_function_call (tree function, tree params) fndecl = function; /* Convert anything with function type to a pointer-to-function. */ - if (pedantic && DECL_MAIN_P (function)) + if (pedantic && DECL_MAIN_P (function) && (complain & tf_error)) pedwarn ("ISO C++ forbids calling %<::main%> from within program"); /* Differs from default_conversion by not setting TREE_ADDRESSABLE @@ -2751,9 +2849,10 @@ build_function_call (tree function, tree params) if (TYPE_PTRMEMFUNC_P (fntype)) { - error ("must use %<.*%> or %<->*%> to call pointer-to-member " - "function in %<%E (...)%>", - original); + if (complain & tf_error) + error ("must use %<.*%> or %<->*%> to call pointer-to-member " + "function in %<%E (...)%>", + original); return error_mark_node; } @@ -2765,7 +2864,8 @@ build_function_call (tree function, tree params) || is_method || TREE_CODE (function) == TEMPLATE_ID_EXPR)) { - error ("%qE cannot be used as a function", original); + if (complain & tf_error) + error ("%qE cannot be used as a function", original); return error_mark_node; } @@ -2783,7 +2883,8 @@ build_function_call (tree function, tree params) /* Convert the parameters to the types declared in the function prototype, or apply default promotions. */ nargs = convert_arguments (nargs, argarray, parm_types, - params, fndecl, LOOKUP_NORMAL); + params, fndecl, LOOKUP_NORMAL, + complain); if (nargs < 0) return error_mark_node; @@ -2818,7 +2919,8 @@ build_function_call (tree function, tree params) static int convert_arguments (int nargs, tree *argarray, - tree typelist, tree values, tree fndecl, int flags) + tree typelist, tree values, tree fndecl, int flags, + tsubst_flags_t complain) { tree typetail, valtail; const char *called_thing = 0; @@ -2853,14 +2955,20 @@ convert_arguments (int nargs, tree *argarray, if (type == void_type_node) { - if (fndecl) - { - error ("too many arguments to %s %q+#D", called_thing, fndecl); - error ("at this point in file"); - } - else - error ("too many arguments to function"); - return i; + if (complain & tf_error) + { + if (fndecl) + { + error ("too many arguments to %s %q+#D", + called_thing, fndecl); + error ("at this point in file"); + } + else + error ("too many arguments to function"); + return i; + } + else + return -1; } /* build_c_cast puts on a NOP_EXPR to make the result not an lvalue. @@ -2888,18 +2996,21 @@ convert_arguments (int nargs, tree *argarray, if (!COMPLETE_TYPE_P (complete_type (type))) { - if (fndecl) - error ("parameter %P of %qD has incomplete type %qT", - i, fndecl, type); - else - error ("parameter %P has incomplete type %qT", i, type); + if (complain & tf_error) + { + if (fndecl) + error ("parameter %P of %qD has incomplete type %qT", + i, fndecl, type); + else + error ("parameter %P has incomplete type %qT", i, type); + } parmval = error_mark_node; } else { parmval = convert_for_initialization (NULL_TREE, type, val, flags, - "argument passing", fndecl, i); + "argument passing", fndecl, i, complain); parmval = convert_for_arg_passing (type, parmval); } @@ -2957,13 +3068,17 @@ convert_arguments (int nargs, tree *argarray, } else { - if (fndecl) - { - error ("too few arguments to %s %q+#D", called_thing, fndecl); - error ("at this point in file"); - } - else - error ("too few arguments to function"); + if (complain & tf_error) + { + if (fndecl) + { + error ("too few arguments to %s %q+#D", + called_thing, fndecl); + error ("at this point in file"); + } + else + error ("too few arguments to function"); + } return -1; } } @@ -2985,7 +3100,8 @@ convert_arguments (int nargs, tree *argarray, tree build_x_binary_op (enum tree_code code, tree arg1, enum tree_code arg1_code, - tree arg2, enum tree_code arg2_code, bool *overloaded_p) + tree arg2, enum tree_code arg2_code, bool *overloaded_p, + tsubst_flags_t complain) { tree orig_arg1; tree orig_arg2; @@ -3007,7 +3123,7 @@ build_x_binary_op (enum tree_code code, tree arg1, enum tree_code arg1_code, expr = build_m_component_ref (arg1, arg2); else expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE, - overloaded_p); + overloaded_p, complain); /* Check for cases such as x+y<= 0) + if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0 + && (complain & tf_warning)) warning (0, "right shift count >= width of type"); } } @@ -3311,9 +3442,15 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, if (TREE_CODE (op1) == INTEGER_CST) { if (tree_int_cst_lt (op1, integer_zero_node)) - warning (0, "left shift count is negative"); + { + if (complain & tf_warning) + warning (0, "left shift count is negative"); + } else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) - warning (0, "left shift count >= width of type"); + { + if (complain & tf_warning) + warning (0, "left shift count >= width of type"); + } } /* Convert the shift-count to an integer, regardless of size of value being shifted. */ @@ -3332,13 +3469,19 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, if (TREE_CODE (op1) == INTEGER_CST) { if (tree_int_cst_lt (op1, integer_zero_node)) - warning (0, (code == LROTATE_EXPR) - ? G_("left rotate count is negative") - : G_("right rotate count is negative")); + { + if (complain & tf_warning) + warning (0, (code == LROTATE_EXPR) + ? G_("left rotate count is negative") + : G_("right rotate count is negative")); + } else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) - warning (0, (code == LROTATE_EXPR) - ? G_("left rotate count >= width of type") - : G_("right rotate count >= width of type")); + { + if (complain & tf_warning) + warning (0, (code == LROTATE_EXPR) + ? G_("left rotate count >= width of type") + : G_("right rotate count >= width of type")); + } } /* Convert the shift-count to an integer, regardless of size of value being shifted. */ @@ -3349,11 +3492,13 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, case EQ_EXPR: case NE_EXPR: - if (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1)) + if ((complain & tf_warning) + && (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1))) warning (OPT_Wfloat_equal, "comparing floating point with == or != is unsafe"); - if ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1)) - || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0))) + if ((complain & tf_warning) + && ((TREE_CODE (orig_op0) == STRING_CST && !integer_zerop (op1)) + || (TREE_CODE (orig_op1) == STRING_CST && !integer_zerop (op0)))) warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour"); build_type = boolean_type_node; @@ -3365,14 +3510,17 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, else if ((code0 == POINTER_TYPE && code1 == POINTER_TYPE) || (TYPE_PTRMEM_P (type0) && TYPE_PTRMEM_P (type1))) result_type = composite_pointer_type (type0, type1, op0, op1, - "comparison"); + "comparison", complain); else if ((code0 == POINTER_TYPE || TYPE_PTRMEM_P (type0)) && null_ptr_cst_p (op1)) { if (TREE_CODE (op0) == ADDR_EXPR && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0))) - warning (OPT_Waddress, "the address of %qD will never be NULL", - TREE_OPERAND (op0, 0)); + { + if (complain & tf_warning) + warning (OPT_Waddress, "the address of %qD will never be NULL", + TREE_OPERAND (op0, 0)); + } result_type = type0; } else if ((code1 == POINTER_TYPE || TYPE_PTRMEM_P (type1)) @@ -3380,19 +3528,28 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, { if (TREE_CODE (op1) == ADDR_EXPR && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0))) - warning (OPT_Waddress, "the address of %qD will never be NULL", - TREE_OPERAND (op1, 0)); + { + if (complain & tf_warning) + warning (OPT_Waddress, "the address of %qD will never be NULL", + TREE_OPERAND (op1, 0)); + } result_type = type1; } else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) { result_type = type0; - pedwarn ("ISO C++ forbids comparison between pointer and integer"); + if (complain & tf_error) + pedwarn ("ISO C++ forbids comparison between pointer and integer"); + else + return error_mark_node; } else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) { result_type = type1; - pedwarn ("ISO C++ forbids comparison between pointer and integer"); + if (complain & tf_error) + pedwarn ("ISO C++ forbids comparison between pointer and integer"); + else + return error_mark_node; } else if (TYPE_PTRMEMFUNC_P (type0) && null_ptr_cst_p (op1)) { @@ -3404,12 +3561,16 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, tree e1 = cp_build_binary_op (EQ_EXPR, pfn0, fold_convert (TREE_TYPE (pfn0), - integer_zero_node)); + integer_zero_node), + complain); tree e2 = cp_build_binary_op (BIT_AND_EXPR, delta0, - integer_one_node); - e2 = cp_build_binary_op (EQ_EXPR, e2, integer_zero_node); - op0 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e1, e2); + integer_one_node, + complain); + e2 = cp_build_binary_op (EQ_EXPR, e2, integer_zero_node, + complain); + op0 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, + complain); op1 = cp_convert (TREE_TYPE (op0), integer_one_node); } else @@ -3420,7 +3581,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, result_type = TREE_TYPE (op0); } else if (TYPE_PTRMEMFUNC_P (type1) && null_ptr_cst_p (op0)) - return cp_build_binary_op (code, op1, op0); + return cp_build_binary_op (code, op1, op0, complain); else if (TYPE_PTRMEMFUNC_P (type0) && TYPE_PTRMEMFUNC_P (type1)) { tree type; @@ -3434,7 +3595,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, tree delta0; tree delta1; - type = composite_pointer_type (type0, type1, op0, op1, "comparison"); + type = composite_pointer_type (type0, type1, op0, op1, "comparison", + complain); if (!same_type_p (TREE_TYPE (op0), type)) op0 = cp_convert_and_check (type, op0); @@ -3469,20 +3631,26 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, e1 = cp_build_binary_op (BIT_AND_EXPR, delta0, - integer_one_node); - e1 = cp_build_binary_op (EQ_EXPR, e1, integer_zero_node); + integer_one_node, + complain); + e1 = cp_build_binary_op (EQ_EXPR, e1, integer_zero_node, + complain); e2 = cp_build_binary_op (BIT_AND_EXPR, delta1, - integer_one_node); - e2 = cp_build_binary_op (EQ_EXPR, e2, integer_zero_node); - e1 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1); + integer_one_node, + complain); + e2 = cp_build_binary_op (EQ_EXPR, e2, integer_zero_node, + complain); + e1 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1, + complain); e2 = cp_build_binary_op (EQ_EXPR, pfn0, fold_convert (TREE_TYPE (pfn0), - integer_zero_node)); - e2 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1); - e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1); - e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2); + integer_zero_node), + complain); + e2 = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1, complain); + e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1, complain); + e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2, complain); } else { @@ -3495,18 +3663,19 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, pointer-to-member is any member with a zero PFN; the DELTA field is unspecified. */ - e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1); + e1 = cp_build_binary_op (EQ_EXPR, delta0, delta1, complain); e2 = cp_build_binary_op (EQ_EXPR, pfn0, fold_convert (TREE_TYPE (pfn0), - integer_zero_node)); - e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2); + integer_zero_node), + complain); + e1 = cp_build_binary_op (TRUTH_ORIF_EXPR, e1, e2, complain); } e2 = build2 (EQ_EXPR, boolean_type_node, pfn0, pfn1); - e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1); + e = cp_build_binary_op (TRUTH_ANDIF_EXPR, e2, e1, complain); if (code == EQ_EXPR) return e; - return cp_build_binary_op (EQ_EXPR, e, integer_zero_node); + return cp_build_binary_op (EQ_EXPR, e, integer_zero_node, complain); } else { @@ -3527,7 +3696,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, shorten = 1; else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) result_type = composite_pointer_type (type0, type1, op0, op1, - "comparison"); + "comparison", complain); break; case LE_EXPR: @@ -3536,7 +3705,10 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, case GT_EXPR: if (TREE_CODE (orig_op0) == STRING_CST || TREE_CODE (orig_op1) == STRING_CST) - warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour"); + { + if (complain & tf_warning) + warning (OPT_Waddress, "comparison with string literal results in unspecified behaviour"); + } build_type = boolean_type_node; if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) @@ -3544,7 +3716,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, short_compare = 1; else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) result_type = composite_pointer_type (type0, type1, op0, op1, - "comparison"); + "comparison", complain); else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST && integer_zerop (op1)) result_type = type0; @@ -3554,12 +3726,18 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) { result_type = type0; - pedwarn ("ISO C++ forbids comparison between pointer and integer"); + if (complain & tf_error) + pedwarn ("ISO C++ forbids comparison between pointer and integer"); + else + return error_mark_node; } else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) { result_type = type1; - pedwarn ("ISO C++ forbids comparison between pointer and integer"); + if (complain & tf_error) + pedwarn ("ISO C++ forbids comparison between pointer and integer"); + else + return error_mark_node; } break; @@ -3573,7 +3751,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, build_type = integer_type_node; if (code0 != REAL_TYPE || code1 != REAL_TYPE) { - error ("unordered comparison on non-floating point argument"); + if (complain & tf_error) + error ("unordered comparison on non-floating point argument"); return error_mark_node; } common = 1; @@ -3611,8 +3790,9 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, if (!result_type) { - error ("invalid operands of types %qT and %qT to binary %qO", - TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code); + if (complain & tf_error) + error ("invalid operands of types %qT and %qT to binary %qO", + TREE_TYPE (orig_op0), TREE_TYPE (orig_op1), code); return error_mark_node; } @@ -3742,7 +3922,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, if (TREE_CODE (TREE_TYPE (orig_op0)) == ENUMERAL_TYPE && TREE_CODE (TREE_TYPE (orig_op1)) == ENUMERAL_TYPE && TYPE_MAIN_VARIANT (TREE_TYPE (orig_op0)) - != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1))) + != TYPE_MAIN_VARIANT (TREE_TYPE (orig_op1)) + && (complain & tf_warning)) { warning (OPT_Wsign_compare, "comparison between types %q#T and %q#T", TREE_TYPE (orig_op0), TREE_TYPE (orig_op1)); @@ -3779,7 +3960,7 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, && int_fits_type_p (orig_op0, c_common_signed_type (result_type))))) /* OK */; - else + else if (complain & tf_warning) warning (OPT_Wsign_compare, "comparison between signed and unsigned integer expressions"); @@ -3824,7 +4005,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, && bits < HOST_BITS_PER_LONG && unsignedp) { mask = (~ (HOST_WIDE_INT) 0) << bits; - if ((mask & constant) != mask) + if ((mask & constant) != mask + && (complain & tf_warning)) warning (OPT_Wsign_compare, "comparison of promoted ~unsigned with constant"); } } @@ -3832,7 +4014,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, && (TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (result_type)) && (TYPE_PRECISION (TREE_TYPE (primop1)) - < TYPE_PRECISION (result_type))) + < TYPE_PRECISION (result_type)) + && (complain & tf_warning)) warning (OPT_Wsign_compare, "comparison of promoted ~unsigned with unsigned"); } } @@ -3848,7 +4031,8 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, && code != EQ_EXPR && code != NE_EXPR) /* Or if one of OP0 or OP1 is neither a pointer nor NULL. */ || (!null_ptr_cst_p (orig_op0) && TREE_CODE (TREE_TYPE (op0)) != POINTER_TYPE) - || (!null_ptr_cst_p (orig_op1) && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE))) + || (!null_ptr_cst_p (orig_op1) && TREE_CODE (TREE_TYPE (op1)) != POINTER_TYPE)) + && (complain & tf_warning)) /* Some sort of arithmetic operation involving NULL was performed. Note that pointer-difference and pointer-addition have already been handled above, and so we don't end up here in @@ -3934,7 +4118,8 @@ pointer_diff (tree op0, tree op1, tree ptrtype) op0 = cp_build_binary_op (MINUS_EXPR, cp_convert (restype, op0), - cp_convert (restype, op1)); + cp_convert (restype, op1), + tf_warning_or_error); /* This generates an error if op1 is a pointer to an incomplete type. */ if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (op1)))) @@ -3955,7 +4140,7 @@ pointer_diff (tree op0, tree op1, tree ptrtype) and XARG is the operand. */ tree -build_x_unary_op (enum tree_code code, tree xarg) +build_x_unary_op (enum tree_code code, tree xarg, tsubst_flags_t complain) { tree orig_expr = xarg; tree exp; @@ -3987,7 +4172,7 @@ build_x_unary_op (enum tree_code code, tree xarg) /* Don't look for a function. */; else exp = build_new_op (code, LOOKUP_NORMAL, xarg, NULL_TREE, NULL_TREE, - /*overloaded_p=*/NULL); + /*overloaded_p=*/NULL, complain); if (!exp && code == ADDR_EXPR) { /* A pointer to member-function can be formed only by saying @@ -3998,10 +4183,10 @@ build_x_unary_op (enum tree_code code, tree xarg) if (TREE_CODE (xarg) != OFFSET_REF || !TYPE_P (TREE_OPERAND (xarg, 0))) { - error ("invalid use of %qE to form a pointer-to-member-function", - xarg); - if (TREE_CODE (xarg) != OFFSET_REF) - inform (" a qualified-id is required"); + error ("invalid use of %qE to form a pointer-to-member-function", + xarg); + if (TREE_CODE (xarg) != OFFSET_REF) + inform (" a qualified-id is required"); return error_mark_node; } else @@ -4028,9 +4213,9 @@ build_x_unary_op (enum tree_code code, tree xarg) PTRMEM_OK_P (xarg) = ptrmem; } } - else if (TREE_CODE (xarg) == TARGET_EXPR) + else if (TREE_CODE (xarg) == TARGET_EXPR && (complain & tf_warning)) warning (0, "taking address of temporary"); - exp = build_unary_op (ADDR_EXPR, xarg, 0); + exp = cp_build_unary_op (ADDR_EXPR, xarg, 0, complain); } if (processing_template_decl && exp != error_mark_node) @@ -4063,7 +4248,8 @@ condition_conversion (tree expr) tree t; if (processing_template_decl) return expr; - t = perform_implicit_conversion (boolean_type_node, expr); + t = perform_implicit_conversion (boolean_type_node, expr, + tf_warning_or_error); t = fold_build_cleanup_point_expr (boolean_type_node, t); return t; } @@ -4105,7 +4291,8 @@ build_nop (tree type, tree expr) (such as from short to int). */ tree -build_unary_op (enum tree_code code, tree xarg, int noconvert) +cp_build_unary_op (enum tree_code code, tree xarg, int noconvert, + tsubst_flags_t complain) { /* No default_conversion here. It causes trouble for ADDR_EXPR. */ tree arg = xarg; @@ -4184,7 +4371,8 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) break; case TRUTH_NOT_EXPR: - arg = perform_implicit_conversion (boolean_type_node, arg); + arg = perform_implicit_conversion (boolean_type_node, arg, + complain); val = invert_truthvalue (arg); if (arg != error_mark_node) return val; @@ -4234,9 +4422,9 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) tree real, imag; arg = stabilize_reference (arg); - real = build_unary_op (REALPART_EXPR, arg, 1); - imag = build_unary_op (IMAGPART_EXPR, arg, 1); - real = build_unary_op (code, real, 1); + real = cp_build_unary_op (REALPART_EXPR, arg, 1, complain); + imag = cp_build_unary_op (IMAGPART_EXPR, arg, 1, complain); + real = cp_build_unary_op (code, real, 1, complain); if (real == error_mark_node || imag == error_mark_node) return error_mark_node; return build2 (COMPLEX_EXPR, TREE_TYPE (arg), @@ -4264,10 +4452,15 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) /* Report something read-only. */ if (CP_TYPE_CONST_P (TREE_TYPE (arg)) - || TREE_READONLY (arg)) - readonly_error (arg, ((code == PREINCREMENT_EXPR - || code == POSTINCREMENT_EXPR) - ? "increment" : "decrement")); + || TREE_READONLY (arg)) + { + if (complain & tf_error) + readonly_error (arg, ((code == PREINCREMENT_EXPR + || code == POSTINCREMENT_EXPR) + ? "increment" : "decrement")); + else + return error_mark_node; + } { tree inc; @@ -4281,9 +4474,14 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) /* ARM $5.2.5 last annotation says this should be forbidden. */ if (TREE_CODE (argtype) == ENUMERAL_TYPE) - pedwarn ((code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) - ? G_("ISO C++ forbids incrementing an enum") - : G_("ISO C++ forbids decrementing an enum")); + { + if (complain & tf_error) + pedwarn ((code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) + ? G_("ISO C++ forbids incrementing an enum") + : G_("ISO C++ forbids decrementing an enum")); + else + return error_mark_node; + } /* Compute the increment. */ @@ -4292,18 +4490,29 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) tree type = complete_type (TREE_TYPE (argtype)); if (!COMPLETE_OR_VOID_TYPE_P (type)) - error (((code == PREINCREMENT_EXPR - || code == POSTINCREMENT_EXPR)) - ? G_("cannot increment a pointer to incomplete type %qT") - : G_("cannot decrement a pointer to incomplete type %qT"), - TREE_TYPE (argtype)); + { + if (complain & tf_error) + error (((code == PREINCREMENT_EXPR + || code == POSTINCREMENT_EXPR)) + ? G_("cannot increment a pointer to incomplete type %qT") + : G_("cannot decrement a pointer to incomplete type %qT"), + TREE_TYPE (argtype)); + else + return error_mark_node; + } else if ((pedantic || warn_pointer_arith) - && !TYPE_PTROB_P (argtype)) - pedwarn ((code == PREINCREMENT_EXPR - || code == POSTINCREMENT_EXPR) - ? G_("ISO C++ forbids incrementing a pointer of type %qT") - : G_("ISO C++ forbids decrementing a pointer of type %qT"), - argtype); + && !TYPE_PTROB_P (argtype)) + { + if (complain & tf_error) + pedwarn ((code == PREINCREMENT_EXPR + || code == POSTINCREMENT_EXPR) + ? G_("ISO C++ forbids incrementing a pointer of type %qT") + : G_("ISO C++ forbids decrementing a pointer of type %qT"), + argtype); + else + return error_mark_node; + } + inc = cxx_sizeof_nowarn (TREE_TYPE (argtype)); } else @@ -4314,7 +4523,8 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) /* Complain about anything else that is not a true lvalue. */ if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) - ? lv_increment : lv_decrement))) + ? lv_increment : lv_decrement), + complain)) return error_mark_node; /* Forbid using -- on `bool'. */ @@ -4322,8 +4532,9 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) { if (code == POSTDECREMENT_EXPR || code == PREDECREMENT_EXPR) { - error ("invalid use of Boolean expression as operand " - "to %"); + if (complain & tf_error) + error ("invalid use of Boolean expression as operand " + "to %"); return error_mark_node; } val = boolean_increment (code, arg); @@ -4351,8 +4562,13 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) return arg; } else if (pedantic && DECL_MAIN_P (arg)) - /* ARM $3.4 */ - pedwarn ("ISO C++ forbids taking address of function %<::main%>"); + { + /* ARM $3.4 */ + if (complain & tf_error) + pedwarn ("ISO C++ forbids taking address of function %<::main%>"); + else + return error_mark_node; + } /* Let &* cancel out to simplify resulting code. */ if (TREE_CODE (arg) == INDIRECT_REF) @@ -4405,13 +4621,15 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) if (! flag_ms_extensions) { tree name = DECL_NAME (fn); - if (current_class_type - && TREE_OPERAND (arg, 0) == current_class_ref) - /* An expression like &memfn. */ - pedwarn ("ISO C++ forbids taking the address of an unqualified" - " or parenthesized non-static member function to form" - " a pointer to member function. Say %<&%T::%D%>", - base, name); + if (!(complain & tf_error)) + return error_mark_node; + else if (current_class_type + && TREE_OPERAND (arg, 0) == current_class_ref) + /* An expression like &memfn. */ + pedwarn ("ISO C++ forbids taking the address of an unqualified" + " or parenthesized non-static member function to form" + " a pointer to member function. Say %<&%T::%D%>", + base, name); else pedwarn ("ISO C++ forbids taking the address of a bound member" " function to form a pointer to member function." @@ -4437,8 +4655,16 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) case CONVERT_EXPR: case FLOAT_EXPR: case FIX_TRUNC_EXPR: - if (! lvalue_p (arg) && pedantic) - pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression"); + /* Even if we're not being pedantic, we cannot allow this + extension when we're instantiating in a SFINAE + context. */ + if (! lvalue_p (arg) && (pedantic || complain == tf_none)) + { + if (complain & tf_error) + pedwarn ("ISO C++ forbids taking the address of a cast to a non-lvalue expression"); + else + return error_mark_node; + } break; case BASELINK: @@ -4457,12 +4683,13 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) tree t; if (!PTRMEM_OK_P (arg)) - return build_unary_op (code, arg, 0); + return cp_build_unary_op (code, arg, 0, complain); t = TREE_OPERAND (arg, 1); if (TREE_CODE (TREE_TYPE (t)) == REFERENCE_TYPE) { - error ("cannot create pointer to reference member %qD", t); + if (complain & tf_error) + error ("cannot create pointer to reference member %qD", t); return error_mark_node; } @@ -4481,7 +4708,7 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) if (TREE_CODE (argtype) != FUNCTION_TYPE && TREE_CODE (argtype) != METHOD_TYPE && TREE_CODE (arg) != OFFSET_REF - && !lvalue_or_else (arg, lv_addressof)) + && !lvalue_or_else (arg, lv_addressof, complain)) return error_mark_node; if (argtype != error_mark_node) @@ -4520,8 +4747,9 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) } else if (DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1))) { - error ("attempt to take address of bit-field structure member %qD", - TREE_OPERAND (arg, 1)); + if (complain & tf_error) + error ("attempt to take address of bit-field structure member %qD", + TREE_OPERAND (arg, 1)); return error_mark_node; } else @@ -4554,10 +4782,18 @@ build_unary_op (enum tree_code code, tree xarg, int noconvert) return fold_if_not_in_template (build1 (code, argtype, arg)); } - error ("%s", errstring); + if (complain & tf_error) + error ("%s", errstring); return error_mark_node; } +/* Hook for the c-common bits that build a unary op. */ +tree +build_unary_op (enum tree_code code, tree xarg, int noconvert) +{ + return cp_build_unary_op (code, xarg, noconvert, tf_warning_or_error); +} + /* Apply unary lvalue-demanding operator CODE to the expression ARG for certain kinds of expressions which are not really lvalues but which we can accept as lvalues. @@ -4577,7 +4813,8 @@ unary_complex_lvalue (enum tree_code code, tree arg) /* Handle (a, b) used as an "lvalue". */ if (TREE_CODE (arg) == COMPOUND_EXPR) { - tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0); + tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 1), 0, + tf_warning_or_error); return build2 (COMPOUND_EXPR, TREE_TYPE (real_result), TREE_OPERAND (arg, 0), real_result); } @@ -4585,7 +4822,7 @@ unary_complex_lvalue (enum tree_code code, tree arg) /* Handle (a ? b : c) used as an "lvalue". */ if (TREE_CODE (arg) == COND_EXPR || TREE_CODE (arg) == MIN_EXPR || TREE_CODE (arg) == MAX_EXPR) - return rationalize_conditional_expr (code, arg); + return rationalize_conditional_expr (code, arg, tf_warning_or_error); /* Handle (a = b), (++a), and (--a) used as an "lvalue". */ if (TREE_CODE (arg) == MODIFY_EXPR @@ -4610,7 +4847,8 @@ unary_complex_lvalue (enum tree_code code, tree arg) if (TREE_CODE (arg) == MODIFY_EXPR || TREE_CODE (arg) == INIT_EXPR) { - tree real_result = build_unary_op (code, TREE_OPERAND (arg, 0), 0); + tree real_result = cp_build_unary_op (code, TREE_OPERAND (arg, 0), 0, + tf_warning_or_error); arg = build2 (COMPOUND_EXPR, TREE_TYPE (real_result), arg, real_result); TREE_NO_WARNING (arg) = 1; @@ -4727,7 +4965,8 @@ cxx_mark_addressable (tree exp) /* Build and return a conditional expression IFEXP ? OP1 : OP2. */ tree -build_x_conditional_expr (tree ifexp, tree op1, tree op2) +build_x_conditional_expr (tree ifexp, tree op1, tree op2, + tsubst_flags_t complain) { tree orig_ifexp = ifexp; tree orig_op1 = op1; @@ -4750,7 +4989,7 @@ build_x_conditional_expr (tree ifexp, tree op1, tree op2) op2 = build_non_dependent_expr (op2); } - expr = build_conditional_expr (ifexp, op1, op2); + expr = build_conditional_expr (ifexp, op1, op2, complain); if (processing_template_decl && expr != error_mark_node) return build_min_non_dep (COND_EXPR, expr, orig_ifexp, orig_op1, orig_op2); @@ -4770,7 +5009,8 @@ tree build_x_compound_expr_from_list (tree list, const char *msg) pedwarn ("%s expression list treated as compound expression", msg); for (list = TREE_CHAIN (list); list; list = TREE_CHAIN (list)) - expr = build_x_compound_expr (expr, TREE_VALUE (list)); + expr = build_x_compound_expr (expr, TREE_VALUE (list), + tf_warning_or_error); } return expr; @@ -4779,7 +5019,7 @@ tree build_x_compound_expr_from_list (tree list, const char *msg) /* Handle overloading of the ',' operator when needed. */ tree -build_x_compound_expr (tree op1, tree op2) +build_x_compound_expr (tree op1, tree op2, tsubst_flags_t complain) { tree result; tree orig_op1 = op1; @@ -4795,9 +5035,9 @@ build_x_compound_expr (tree op1, tree op2) } result = build_new_op (COMPOUND_EXPR, LOOKUP_NORMAL, op1, op2, NULL_TREE, - /*overloaded_p=*/NULL); + /*overloaded_p=*/NULL, complain); if (!result) - result = build_compound_expr (op1, op2); + result = build_compound_expr (op1, op2, complain); if (processing_template_decl && result != error_mark_node) return build_min_non_dep (COMPOUND_EXPR, result, orig_op1, orig_op2); @@ -4808,9 +5048,9 @@ build_x_compound_expr (tree op1, tree op2) /* Build a compound expression. */ tree -build_compound_expr (tree lhs, tree rhs) +build_compound_expr (tree lhs, tree rhs, tsubst_flags_t complain) { - lhs = convert_to_void (lhs, "left-hand operand of comma"); + lhs = convert_to_void (lhs, "left-hand operand of comma", complain); if (lhs == error_mark_node || rhs == error_mark_node) return error_mark_node; @@ -4893,9 +5133,11 @@ convert_ptrmem (tree type, tree expr, bool allow_inverse_p, cond = cp_build_binary_op (EQ_EXPR, expr, - build_int_cst (TREE_TYPE (expr), -1)); + build_int_cst (TREE_TYPE (expr), -1), + tf_warning_or_error); op1 = build_nop (ptrdiff_type_node, expr); - op2 = cp_build_binary_op (PLUS_EXPR, op1, delta); + op2 = cp_build_binary_op (PLUS_EXPR, op1, delta, + tf_warning_or_error); expr = fold_build3 (COND_EXPR, ptrdiff_type_node, cond, op1, op2); @@ -4944,7 +5186,7 @@ ignore_overflows (tree expr, tree orig) static tree build_static_cast_1 (tree type, tree expr, bool c_cast_p, - bool *valid_p) + bool *valid_p, tsubst_flags_t complain) { tree intype; tree result; @@ -5018,7 +5260,7 @@ build_static_cast_1 (tree type, tree expr, bool c_cast_p, t(e);" is well-formed, for some invented temporary variable t. */ result = perform_direct_initialization_if_possible (type, expr, - c_cast_p); + c_cast_p, complain); if (result) { result = convert_from_reference (result); @@ -5039,7 +5281,7 @@ build_static_cast_1 (tree type, tree expr, bool c_cast_p, Any expression can be explicitly converted to type cv void. */ if (TREE_CODE (type) == VOID_TYPE) - return convert_to_void (expr, /*implicit=*/NULL); + return convert_to_void (expr, /*implicit=*/NULL, complain); /* [expr.static.cast] @@ -5145,7 +5387,7 @@ build_static_cast_1 (tree type, tree expr, bool c_cast_p, /* Return an expression representing static_cast(EXPR). */ tree -build_static_cast (tree type, tree expr) +build_static_cast (tree type, tree expr, tsubst_flags_t complain) { tree result; bool valid_p; @@ -5168,12 +5410,14 @@ build_static_cast (tree type, tree expr) && TREE_TYPE (expr) == TREE_TYPE (TREE_OPERAND (expr, 0))) expr = TREE_OPERAND (expr, 0); - result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p); + result = build_static_cast_1 (type, expr, /*c_cast_p=*/false, &valid_p, + complain); if (valid_p) return result; - error ("invalid static_cast from type %qT to type %qT", - TREE_TYPE (expr), type); + if (complain & tf_error) + error ("invalid static_cast from type %qT to type %qT", + TREE_TYPE (expr), type); return error_mark_node; } @@ -5217,7 +5461,7 @@ convert_member_func_to_ptr (tree type, tree expr) static tree build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, - bool *valid_p) + bool *valid_p, tsubst_flags_t complain) { tree intype; @@ -5242,9 +5486,10 @@ build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, { if (! real_lvalue_p (expr)) { - error ("invalid cast of an rvalue expression of type " - "%qT to type %qT", - intype, type); + if (complain & tf_error) + error ("invalid cast of an rvalue expression of type " + "%qT to type %qT", + intype, type); return error_mark_node; } @@ -5252,18 +5497,19 @@ build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, "B" are related class types; the reinterpret_cast does not adjust the pointer. */ if (TYPE_PTR_P (intype) + && (complain & tf_warning) && (comptypes (TREE_TYPE (intype), TREE_TYPE (type), COMPARE_BASE | COMPARE_DERIVED))) warning (0, "casting %qT to %qT does not dereference pointer", intype, type); - expr = build_unary_op (ADDR_EXPR, expr, 0); + expr = cp_build_unary_op (ADDR_EXPR, expr, 0, complain); if (expr != error_mark_node) expr = build_reinterpret_cast_1 (build_pointer_type (TREE_TYPE (type)), expr, c_cast_p, - valid_p); + valid_p, complain); if (expr != error_mark_node) - expr = build_indirect_ref (expr, 0); + expr = cp_build_indirect_ref (expr, 0, complain); return expr; } @@ -5301,8 +5547,13 @@ build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, if (CP_INTEGRAL_TYPE_P (type) && TYPE_PTR_P (intype)) { if (TYPE_PRECISION (type) < TYPE_PRECISION (intype)) - pedwarn ("cast from %qT to %qT loses precision", - intype, type); + { + if (complain & tf_error) + pedwarn ("cast from %qT to %qT loses precision", + intype, type); + else + return error_mark_node; + } } /* [expr.reinterpret.cast] A value of integral or enumeration type can be explicitly @@ -5322,6 +5573,7 @@ build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, check_for_casting_away_constness (intype, type, REINTERPRET_CAST_EXPR); /* Warn about possible alignment problems. */ if (STRICT_ALIGNMENT && warn_cast_align + && (complain & tf_warning) && !VOID_TYPE_P (type) && TREE_CODE (TREE_TYPE (intype)) != FUNCTION_TYPE && COMPLETE_TYPE_P (TREE_TYPE (type)) @@ -5341,7 +5593,7 @@ build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype)) || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type))) { - if (pedantic) + if (pedantic && (complain & tf_warning)) /* Only issue a warning, as we have always supported this where possible, and it is necessary in some cases. DR 195 addresses this issue, but as of 2004/10/26 is still in @@ -5357,7 +5609,8 @@ build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, { if (valid_p) *valid_p = false; - error ("invalid cast from type %qT to type %qT", intype, type); + if (complain & tf_error) + error ("invalid cast from type %qT to type %qT", intype, type); return error_mark_node; } @@ -5365,7 +5618,7 @@ build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, } tree -build_reinterpret_cast (tree type, tree expr) +build_reinterpret_cast (tree type, tree expr, tsubst_flags_t complain) { if (type == error_mark_node || expr == error_mark_node) return error_mark_node; @@ -5382,7 +5635,7 @@ build_reinterpret_cast (tree type, tree expr) } return build_reinterpret_cast_1 (type, expr, /*c_cast_p=*/false, - /*valid_p=*/NULL); + /*valid_p=*/NULL, complain); } /* Perform a const_cast from EXPR to TYPE. If the cast is valid, @@ -5477,7 +5730,8 @@ build_const_cast_1 (tree dst_type, tree expr, bool complain, } if (reference_type) { - expr = build_unary_op (ADDR_EXPR, expr, 0); + expr = cp_build_unary_op (ADDR_EXPR, expr, 0, + complain? tf_warning_or_error : tf_none); expr = build_nop (reference_type, expr); return convert_from_reference (expr); } @@ -5501,7 +5755,7 @@ build_const_cast_1 (tree dst_type, tree expr, bool complain, } tree -build_const_cast (tree type, tree expr) +build_const_cast (tree type, tree expr, tsubst_flags_t complain) { if (type == error_mark_node || error_operand_p (expr)) return error_mark_node; @@ -5517,7 +5771,7 @@ build_const_cast (tree type, tree expr) return convert_from_reference (t); } - return build_const_cast_1 (type, expr, /*complain=*/true, + return build_const_cast_1 (type, expr, complain & tf_error, /*valid_p=*/NULL); } @@ -5525,7 +5779,7 @@ build_const_cast (tree type, tree expr) TYPE of expression EXPR. */ tree -build_c_cast (tree type, tree expr) +build_c_cast (tree type, tree expr, tsubst_flags_t complain) { tree value = expr; tree result; @@ -5563,12 +5817,16 @@ build_c_cast (tree type, tree expr) NIHCL uses it. It is not valid ISO C++ however. */ if (TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE) { - pedwarn ("ISO C++ forbids casting to an array type %qT", type); + if (complain & tf_error) + pedwarn ("ISO C++ forbids casting to an array type %qT", type); + else + return error_mark_node; type = build_pointer_type (TREE_TYPE (type)); } else { - error ("ISO C++ forbids casting to an array type %qT", type); + if (complain & tf_error) + error ("ISO C++ forbids casting to an array type %qT", type); return error_mark_node; } } @@ -5576,7 +5834,8 @@ build_c_cast (tree type, tree expr) if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE) { - error ("invalid cast to function type %qT", type); + if (complain & tf_error) + error ("invalid cast to function type %qT", type); return error_mark_node; } @@ -5588,11 +5847,11 @@ build_c_cast (tree type, tree expr) /* Or a static cast. */ result = build_static_cast_1 (type, value, /*c_cast_p=*/true, - &valid_p); + &valid_p, complain); /* Or a reinterpret_cast. */ if (!valid_p) result = build_reinterpret_cast_1 (type, value, /*c_cast_p=*/true, - &valid_p); + &valid_p, complain); /* The static_cast or reinterpret_cast may be followed by a const_cast. */ if (valid_p @@ -5624,6 +5883,13 @@ build_c_cast (tree type, tree expr) return error_mark_node; } +/* For use from the C common bits. */ +tree +build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) +{ + return cp_build_modify_expr (lhs, modifycode, rhs, tf_warning_or_error); +} + /* Build an assignment expression of lvalue LHS from value RHS. MODIFYCODE is the code for a binary operator that we use to combine the old value of LHS with RHS to get the new value. @@ -5632,7 +5898,8 @@ build_c_cast (tree type, tree expr) C++: If MODIFYCODE is INIT_EXPR, then leave references unbashed. */ tree -build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) +cp_build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs, + tsubst_flags_t complain) { tree result; tree newrhs = rhs; @@ -5657,13 +5924,13 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) TREE_OPERAND (lhs, 1)); return build2 (COMPOUND_EXPR, lhstype, lhs, - build_modify_expr (TREE_OPERAND (lhs, 0), - modifycode, rhs)); + cp_build_modify_expr (TREE_OPERAND (lhs, 0), + modifycode, rhs, complain)); /* Handle (a, b) used as an "lvalue". */ case COMPOUND_EXPR: - newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), - modifycode, rhs); + newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 1), + modifycode, rhs, complain); if (newrhs == error_mark_node) return error_mark_node; return build2 (COMPOUND_EXPR, lhstype, @@ -5674,7 +5941,8 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) lhs = build2 (TREE_CODE (lhs), TREE_TYPE (lhs), stabilize_reference (TREE_OPERAND (lhs, 0)), TREE_OPERAND (lhs, 1)); - newrhs = build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs); + newrhs = cp_build_modify_expr (TREE_OPERAND (lhs, 0), modifycode, rhs, + complain); if (newrhs == error_mark_node) return error_mark_node; return build2 (COMPOUND_EXPR, lhstype, lhs, newrhs); @@ -5683,7 +5951,7 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) case MAX_EXPR: /* MIN_EXPR and MAX_EXPR are currently only permitted as lvalues, when neither operand has side-effects. */ - if (!lvalue_or_else (lhs, lv_assign)) + if (!lvalue_or_else (lhs, lv_assign, complain)) return error_mark_node; gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (lhs, 0)) @@ -5709,7 +5977,8 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) if (VOID_TYPE_P (TREE_TYPE (rhs))) { - error ("void value not ignored as it ought to be"); + if (complain & tf_error) + error ("void value not ignored as it ought to be"); return error_mark_node; } @@ -5717,15 +5986,16 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) /* Check this here to avoid odd errors when trying to convert a throw to the type of the COND_EXPR. */ - if (!lvalue_or_else (lhs, lv_assign)) + if (!lvalue_or_else (lhs, lv_assign, complain)) return error_mark_node; cond = build_conditional_expr (TREE_OPERAND (lhs, 0), - build_modify_expr (TREE_OPERAND (lhs, 1), - modifycode, rhs), - build_modify_expr (TREE_OPERAND (lhs, 2), - modifycode, rhs)); + cp_build_modify_expr (TREE_OPERAND (lhs, 1), + modifycode, rhs, complain), + cp_build_modify_expr (TREE_OPERAND (lhs, 2), + modifycode, rhs, complain), + complain); if (cond == error_mark_node) return cond; @@ -5757,7 +6027,8 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) { result = build_special_member_call (lhs, complete_ctor_identifier, build_tree_list (NULL_TREE, rhs), - lhstype, LOOKUP_NORMAL); + lhstype, LOOKUP_NORMAL, + complain); if (result == NULL_TREE) return error_mark_node; return result; @@ -5778,7 +6049,8 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) { result = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs, make_node (NOP_EXPR), - /*overloaded_p=*/NULL); + /*overloaded_p=*/NULL, + complain); if (result == NULL_TREE) return error_mark_node; return result; @@ -5795,11 +6067,13 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) || MAYBE_CLASS_TYPE_P (lhstype))); lhs = stabilize_reference (lhs); - newrhs = cp_build_binary_op (modifycode, lhs, rhs); + newrhs = cp_build_binary_op (modifycode, lhs, rhs, + complain); if (newrhs == error_mark_node) { - error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode, - TREE_TYPE (lhs), TREE_TYPE (rhs)); + if (complain & tf_error) + error (" in evaluation of %<%Q(%#T, %#T)%>", modifycode, + TREE_TYPE (lhs), TREE_TYPE (rhs)); return error_mark_node; } @@ -5811,7 +6085,7 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) } /* The left-hand side must be an lvalue. */ - if (!lvalue_or_else (lhs, lv_assign)) + if (!lvalue_or_else (lhs, lv_assign, complain)) return error_mark_node; /* Warn about modifying something that is `const'. Don't warn if @@ -5826,7 +6100,12 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) effectively const. */ || (CLASS_TYPE_P (lhstype) && C_TYPE_FIELDS_READONLY (lhstype)))) - readonly_error (lhs, "assignment"); + { + if (complain & tf_error) + readonly_error (lhs, "assignment"); + else + return error_mark_node; + } /* If storing into a structure or union member, it has probably been given type `int'. Compute the type that would go with the actual @@ -5867,8 +6146,9 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) if (!same_or_base_type_p (TYPE_MAIN_VARIANT (lhstype), TYPE_MAIN_VARIANT (TREE_TYPE (rhs)))) { - error ("incompatible types in assignment of %qT to %qT", - TREE_TYPE (rhs), lhstype); + if (complain & tf_error) + error ("incompatible types in assignment of %qT to %qT", + TREE_TYPE (rhs), lhstype); return error_mark_node; } @@ -5877,10 +6157,13 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) { /* This routine is used for both initialization and assignment. Make sure the diagnostic message differentiates the context. */ - if (modifycode == INIT_EXPR) - error ("array used as initializer"); - else - error ("invalid array assignment"); + if (complain & tf_error) + { + if (modifycode == INIT_EXPR) + error ("array used as initializer"); + else + error ("invalid array assignment"); + } return error_mark_node; } @@ -5888,12 +6171,13 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) ? 1 + (modifycode != INIT_EXPR): 0; return build_vec_init (lhs, NULL_TREE, newrhs, /*explicit_default_init_p=*/false, - from_array); + from_array, complain); } if (modifycode == INIT_EXPR) newrhs = convert_for_initialization (lhs, lhstype, newrhs, LOOKUP_NORMAL, - "initialization", NULL_TREE, 0); + "initialization", NULL_TREE, 0, + complain); else { /* Avoid warnings on enum bit fields. */ @@ -5901,12 +6185,12 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) && TREE_CODE (lhstype) == INTEGER_TYPE) { newrhs = convert_for_assignment (olhstype, newrhs, "assignment", - NULL_TREE, 0); + NULL_TREE, 0, complain); newrhs = convert_force (lhstype, newrhs, 0); } else newrhs = convert_for_assignment (lhstype, newrhs, "assignment", - NULL_TREE, 0); + NULL_TREE, 0, complain); if (TREE_CODE (newrhs) == CALL_EXPR && TYPE_NEEDS_CONSTRUCTING (lhstype)) newrhs = build_cplus_new (lhstype, newrhs); @@ -5952,11 +6236,12 @@ build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) return result; } return convert_for_assignment (olhstype, result, "assignment", - NULL_TREE, 0); + NULL_TREE, 0, complain); } tree -build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) +build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs, + tsubst_flags_t complain) { if (processing_template_decl) return build_min_nt (MODOP_EXPR, lhs, @@ -5966,14 +6251,15 @@ build_x_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) { tree rval = build_new_op (MODIFY_EXPR, LOOKUP_NORMAL, lhs, rhs, make_node (modifycode), - /*overloaded_p=*/NULL); + /*overloaded_p=*/NULL, + complain); if (rval) { TREE_NO_WARNING (rval) = 1; return rval; } } - return build_modify_expr (lhs, modifycode, rhs); + return cp_build_modify_expr (lhs, modifycode, rhs, complain); } /* Helper function for get_delta_difference which assumes FROM is a base @@ -6151,7 +6437,8 @@ build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p) if (same_type_p (to_type, pfn_type)) return pfn; else if (integer_zerop (n)) - return build_reinterpret_cast (to_type, pfn); + return build_reinterpret_cast (to_type, pfn, + tf_warning_or_error); } if (TREE_SIDE_EFFECTS (pfn)) @@ -6170,15 +6457,16 @@ build_ptrmemfunc (tree type, tree pfn, int force, bool c_cast_p) gcc_assert (same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (delta), ptrdiff_type_node)); if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_delta) - n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node); - delta = cp_build_binary_op (PLUS_EXPR, delta, n); + n = cp_build_binary_op (LSHIFT_EXPR, n, integer_one_node, + tf_warning_or_error); + delta = cp_build_binary_op (PLUS_EXPR, delta, n, tf_warning_or_error); return build_ptrmemfunc1 (to_type, delta, npfn); } /* Handle null pointer to member function conversions. */ if (integer_zerop (pfn)) { - pfn = build_c_cast (type, integer_zero_node); + pfn = build_c_cast (type, integer_zero_node, tf_warning_or_error); return build_ptrmemfunc1 (to_type, integer_zero_node, pfn); @@ -6314,7 +6602,8 @@ delta_from_ptrmemfunc (tree t) static tree convert_for_assignment (tree type, tree rhs, - const char *errtype, tree fndecl, int parmnum) + const char *errtype, tree fndecl, int parmnum, + tsubst_flags_t complain) { tree rhstype; enum tree_code coder; @@ -6338,7 +6627,8 @@ convert_for_assignment (tree type, tree rhs, /* The RHS of an assignment cannot have void type. */ if (coder == VOID_TYPE) { - error ("void value not ignored as it ought to be"); + if (complain & tf_error) + error ("void value not ignored as it ought to be"); return error_mark_node; } @@ -6391,16 +6681,20 @@ convert_for_assignment (tree type, tree rhs, rhs = cp_convert (strip_top_quals (type), rhs); else { - /* If the right-hand side has unknown type, then it is an - overloaded function. Call instantiate_type to get error - messages. */ - if (rhstype == unknown_type_node) - instantiate_type (type, rhs, tf_warning_or_error); - else if (fndecl) - error ("cannot convert %qT to %qT for argument %qP to %qD", - rhstype, type, parmnum, fndecl); - else - error ("cannot convert %qT to %qT in %s", rhstype, type, errtype); + if (complain & tf_error) + { + /* If the right-hand side has unknown type, then it is an + overloaded function. Call instantiate_type to get error + messages. */ + if (rhstype == unknown_type_node) + instantiate_type (type, rhs, tf_warning_or_error); + else if (fndecl) + error ("cannot convert %qT to %qT for argument %qP to %qD", + rhstype, type, parmnum, fndecl); + else + error ("cannot convert %qT to %qT in %s", rhstype, type, + errtype); + } return error_mark_node; } } @@ -6409,7 +6703,8 @@ convert_for_assignment (tree type, tree rhs, const enum tree_code codel = TREE_CODE (type); if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) && coder == codel - && check_missing_format_attribute (type, rhstype)) + && check_missing_format_attribute (type, rhstype) + && (complain & tf_warning)) warning (OPT_Wmissing_format_attribute, "%s might be a candidate for a format attribute", errtype); @@ -6421,14 +6716,15 @@ convert_for_assignment (tree type, tree rhs, && type == boolean_type_node && TREE_CODE (rhs) == MODIFY_EXPR && !TREE_NO_WARNING (rhs) - && TREE_TYPE (rhs) != boolean_type_node) + && TREE_TYPE (rhs) != boolean_type_node + && (complain & tf_warning)) { warning (OPT_Wparentheses, "suggest parentheses around assignment used as truth value"); TREE_NO_WARNING (rhs) = 1; } - return perform_implicit_conversion (strip_top_quals (type), rhs); + return perform_implicit_conversion (strip_top_quals (type), rhs, complain); } /* Convert RHS to be of type TYPE. @@ -6449,7 +6745,8 @@ convert_for_assignment (tree type, tree rhs, tree convert_for_initialization (tree exp, tree type, tree rhs, int flags, - const char *errtype, tree fndecl, int parmnum) + const char *errtype, tree fndecl, int parmnum, + tsubst_flags_t complain) { enum tree_code codel = TREE_CODE (type); tree rhstype; @@ -6517,7 +6814,8 @@ convert_for_initialization (tree exp, tree type, tree rhs, int flags, if (MAYBE_CLASS_TYPE_P (type)) return ocp_convert (type, rhs, CONV_IMPLICIT|CONV_FORCE_TEMP, flags); - return convert_for_assignment (type, rhs, errtype, fndecl, parmnum); + return convert_for_assignment (type, rhs, errtype, fndecl, parmnum, + complain); } /* If RETVAL is the address of, or a reference to, a local variable or @@ -6810,7 +7108,8 @@ check_return_expr (tree retval, bool *no_warning) to the type of return value's location to handle the case that functype is smaller than the valtype. */ retval = convert_for_initialization - (NULL_TREE, functype, retval, flags, "return", NULL_TREE, 0); + (NULL_TREE, functype, retval, flags, "return", NULL_TREE, 0, + tf_warning_or_error); retval = convert (valtype, retval); /* If the conversion failed, treat this just like `return;'. */ @@ -7174,11 +7473,11 @@ non_reference (tree t) how the lvalue is being used and so selects the error message. */ int -lvalue_or_else (const_tree ref, enum lvalue_use use) +lvalue_or_else (const_tree ref, enum lvalue_use use, tsubst_flags_t complain) { int win = lvalue_p (ref); - if (!win) + if (!win && (complain & tf_error)) lvalue_error (use); return win; diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c index c48a7852609..4fdb07ff0b9 100644 --- a/gcc/cp/typeck2.c +++ b/gcc/cp/typeck2.c @@ -707,7 +707,8 @@ digest_init (tree type, tree init) tree *exp; init = convert_for_initialization (0, type, init, LOOKUP_NORMAL, - "initialization", NULL_TREE, 0); + "initialization", NULL_TREE, 0, + tf_warning_or_error); exp = &init; /* Skip any conversions since we'll be outputting the underlying @@ -751,7 +752,8 @@ digest_init (tree type, tree init) return convert_for_initialization (NULL_TREE, type, init, LOOKUP_NORMAL | LOOKUP_ONLYCONVERTING, - "initialization", NULL_TREE, 0); + "initialization", NULL_TREE, 0, + tf_warning_or_error); } } @@ -849,7 +851,8 @@ process_init_constructor_array (tree type, tree init) TARGET_EXPRs. If the type in question is a class, just build one up; if it's an array, recurse. */ if (MAYBE_CLASS_TYPE_P (TREE_TYPE (type))) - next = build_functional_cast (TREE_TYPE (type), NULL_TREE); + next = build_functional_cast (TREE_TYPE (type), NULL_TREE, + tf_warning_or_error); else next = build_constructor (NULL_TREE, NULL); next = digest_init (TREE_TYPE (type), next); @@ -936,7 +939,8 @@ process_init_constructor_record (tree type, tree init) for us, so build up TARGET_EXPRs. If the type in question is a class, just build one up; if it's an array, recurse. */ if (MAYBE_CLASS_TYPE_P (TREE_TYPE (field))) - next = build_functional_cast (TREE_TYPE (field), NULL_TREE); + next = build_functional_cast (TREE_TYPE (field), NULL_TREE, + tf_warning_or_error); else next = build_constructor (NULL_TREE, NULL); @@ -1165,7 +1169,8 @@ build_x_arrow (tree expr) { while ((expr = build_new_op (COMPONENT_REF, LOOKUP_NORMAL, expr, NULL_TREE, NULL_TREE, - /*overloaded_p=*/NULL))) + /*overloaded_p=*/NULL, + tf_warning_or_error))) { if (expr == error_mark_node) return error_mark_node; @@ -1205,7 +1210,7 @@ build_x_arrow (tree expr) return expr; } - return build_indirect_ref (last_rval, NULL); + return cp_build_indirect_ref (last_rval, NULL, tf_warning_or_error); } if (types_memoized) @@ -1297,7 +1302,7 @@ build_m_component_ref (tree datum, tree component) datum = build2 (POINTER_PLUS_EXPR, ptype, fold_convert (ptype, datum), build_nop (sizetype, component)); - return build_indirect_ref (datum, 0); + return cp_build_indirect_ref (datum, 0, tf_warning_or_error); } else return build2 (OFFSET_REF, type, datum, component); @@ -1306,7 +1311,7 @@ build_m_component_ref (tree datum, tree component) /* Return a tree node for the expression TYPENAME '(' PARMS ')'. */ tree -build_functional_cast (tree exp, tree parms) +build_functional_cast (tree exp, tree parms, tsubst_flags_t complain) { /* This is either a call to a constructor, or a C cast in C++'s `functional' notation. */ @@ -1337,7 +1342,7 @@ build_functional_cast (tree exp, tree parms) /* This must build a C cast. */ parms = build_x_compound_expr_from_list (parms, "functional cast"); - return build_c_cast (type, parms); + return build_c_cast (type, parms, complain); } /* Prepare to evaluate as a call to a constructor. If this expression @@ -1358,7 +1363,7 @@ build_functional_cast (tree exp, tree parms) conversion is equivalent (in definedness, and if defined in meaning) to the corresponding cast expression. */ if (parms && TREE_CHAIN (parms) == NULL_TREE) - return build_c_cast (type, TREE_VALUE (parms)); + return build_c_cast (type, TREE_VALUE (parms), complain); /* [expr.type.conv] @@ -1378,7 +1383,7 @@ build_functional_cast (tree exp, tree parms) /* Call the constructor. */ exp = build_special_member_call (NULL_TREE, complete_ctor_identifier, parms, - type, LOOKUP_NORMAL); + type, LOOKUP_NORMAL, complain); if (exp == error_mark_node) return error_mark_node; diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 05e9c267e86..4adfe1d6947 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,18 @@ +2008-03-25 Douglas Gregor + + * g++.dg/template/sfinae4.C: New. + * g++.dg/template/sfinae5.C: New. + * g++.dg/template/sfinae6.C: New. + * g++.dg/template/sfinae6_neg.C: New. + * g++.dg/template/sfinae7.C: New. + * g++.dg/template/sfinae8.C: New. + * g++.dg/template/sfinae9.C: New. + * g++.dg/template/sfinae10.C: New. + * g++.dg/template/sfinae11.C: New. + * g++.dg/template/sfinae12.C: New. + * g++.dg/template/sfinae13.C: New. + * g++.dg/template/sfinae14C: New. + 2008-03-25 Naveen.H.S * gcc.target/sh/sh2a-bclr.c: New test. diff --git a/gcc/testsuite/g++.dg/template/sfinae10.C b/gcc/testsuite/g++.dg/template/sfinae10.C new file mode 100644 index 00000000000..e0680db65a6 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae10.C @@ -0,0 +1,181 @@ +// DR 339 +// +// Test of the use of various unary operators with SFINAE + +// Boilerplate helpers +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); +template struct type { }; + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +#define JOIN( X, Y ) DO_JOIN( X, Y ) +#define DO_JOIN( X, Y ) DO_JOIN2(X,Y) +#define DO_JOIN2( X, Y ) X##Y + +#define DEFINE_PREFIX_UNARY_TRAIT(Name,Op) \ +template \ + typename enable_if<(sizeof(Op create_a(), 1) > 0), \ + yes_type>::type \ + JOIN(check_,Name)(int); \ + \ +template \ + no_type JOIN(check_,Name)(...); \ + \ +template \ +struct Name \ +{ \ + static const bool value = \ + (sizeof(JOIN(check_,Name)(0)) == sizeof(yes_type)); \ +} + +#define DEFINE_POSTFIX_UNARY_TRAIT(Name,Op) \ +template \ + typename enable_if<(sizeof(create_a() Op, 1) > 0), \ + yes_type>::type \ + JOIN(check_,Name)(int); \ + \ +template \ + no_type JOIN(check_,Name)(...); \ + \ +template \ +struct Name \ +{ \ + static const bool value = \ + (sizeof(JOIN(check_,Name)(0)) == sizeof(yes_type)); \ +} + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) +#else +# define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] +#endif + +struct W { + W operator+(); + W operator-(); + int operator*(); + W operator~(); + bool operator!(); + W& operator++(); + W& operator--(); + W& operator++(int); + W& operator--(int); +}; + +struct X { }; +X operator+(X); +X operator-(X); +int operator*(X); +X operator~(X); +bool operator!(X); +X& operator++(X&); +X& operator--(X&); +X& operator++(X&, int); +X& operator--(X&, int); + +struct Y { }; + +struct Z { +private: + Z operator+(); // { dg-error "is private" } + Z operator-(); // { dg-error "is private" } + int operator*(); // { dg-error "is private" } + Z operator~(); // { dg-error "is private" } + bool operator!(); // { dg-error "is private" } + Z& operator++(); // { dg-error "is private" } + Z& operator--(); // { dg-error "is private" } + Z& operator++(int); // { dg-error "is private" } + Z& operator--(int); // { dg-error "is private" } +}; + +// has_unary_plus +DEFINE_PREFIX_UNARY_TRAIT(has_unary_plus, +); // { dg-error "within this context" } +STATIC_ASSERT((has_unary_plus::value)); +STATIC_ASSERT((!has_unary_plus::value)); +STATIC_ASSERT((has_unary_plus::value)); +STATIC_ASSERT((has_unary_plus::value)); +STATIC_ASSERT((!has_unary_plus::value)); + +// is_negatable +DEFINE_PREFIX_UNARY_TRAIT(is_negatable, -); // { dg-error "within this context" } +STATIC_ASSERT((is_negatable::value)); +STATIC_ASSERT((!is_negatable::value)); +STATIC_ASSERT((is_negatable::value)); +STATIC_ASSERT((is_negatable::value)); +STATIC_ASSERT((!is_negatable::value)); + +// is_dereferenceable +DEFINE_PREFIX_UNARY_TRAIT(is_dereferenceable, *); // { dg-error "within this context" } +STATIC_ASSERT((!is_dereferenceable::value)); +STATIC_ASSERT((is_dereferenceable::value)); +STATIC_ASSERT((is_dereferenceable::value)); +STATIC_ASSERT((is_dereferenceable::value)); +STATIC_ASSERT((!is_dereferenceable::value)); + +// has_bitwise_not +DEFINE_PREFIX_UNARY_TRAIT(has_bitwise_not, ~); // { dg-error "within this context" } +STATIC_ASSERT((has_bitwise_not::value)); +STATIC_ASSERT((!has_bitwise_not::value)); +STATIC_ASSERT((has_bitwise_not::value)); +STATIC_ASSERT((has_bitwise_not::value)); +STATIC_ASSERT((!has_bitwise_not::value)); + +// has_truth_not +DEFINE_PREFIX_UNARY_TRAIT(has_truth_not, !); // { dg-error "within this context" } +STATIC_ASSERT((has_truth_not::value)); +STATIC_ASSERT((has_truth_not::value)); +STATIC_ASSERT((has_truth_not::value)); +STATIC_ASSERT((has_truth_not::value)); +STATIC_ASSERT((!has_truth_not::value)); + +// has_preincrement +DEFINE_PREFIX_UNARY_TRAIT(has_preincrement, ++); // { dg-error "within this context" } +STATIC_ASSERT((has_preincrement::value)); +STATIC_ASSERT((has_preincrement::value)); +STATIC_ASSERT((!has_preincrement::value)); +STATIC_ASSERT((has_preincrement::value)); +STATIC_ASSERT((has_preincrement::value)); +STATIC_ASSERT((!has_preincrement::value)); + +// has_predecrement +DEFINE_PREFIX_UNARY_TRAIT(has_predecrement, --); // { dg-error "within this context" } +STATIC_ASSERT((has_predecrement::value)); +STATIC_ASSERT((has_predecrement::value)); +STATIC_ASSERT((!has_predecrement::value)); +STATIC_ASSERT((has_predecrement::value)); +STATIC_ASSERT((has_predecrement::value)); +STATIC_ASSERT((!has_predecrement::value)); + +// has_postincrement +DEFINE_POSTFIX_UNARY_TRAIT(has_postincrement, ++); // { dg-error "within this context" } +STATIC_ASSERT((has_postincrement::value)); +STATIC_ASSERT((has_postincrement::value)); +STATIC_ASSERT((!has_postincrement::value)); +STATIC_ASSERT((has_postincrement::value)); +STATIC_ASSERT((has_postincrement::value)); +STATIC_ASSERT((!has_postincrement::value)); + +// has_postdecrement +DEFINE_POSTFIX_UNARY_TRAIT(has_postdecrement, --); // { dg-error "within this context" } +STATIC_ASSERT((has_postdecrement::value)); +STATIC_ASSERT((has_postdecrement::value)); +STATIC_ASSERT((!has_postdecrement::value)); +STATIC_ASSERT((has_postdecrement::value)); +STATIC_ASSERT((has_postdecrement::value)); +STATIC_ASSERT((!has_postdecrement::value)); + +// Check for private members +STATIC_ASSERT((has_unary_plus::value)); // { dg-error "instantiated from here" } +STATIC_ASSERT((is_negatable::value)); // { dg-error "instantiated from here" } +STATIC_ASSERT((is_dereferenceable::value)); // { dg-error "instantiated from here" } +STATIC_ASSERT((has_bitwise_not::value)); // { dg-error "instantiated from here" } +STATIC_ASSERT((has_truth_not::value)); // { dg-error "instantiated from here" } +STATIC_ASSERT((has_preincrement::value)); // { dg-error "instantiated from here" } +STATIC_ASSERT((has_predecrement::value)); // { dg-error "instantiated from here" } +STATIC_ASSERT((has_postincrement::value)); // { dg-error "instantiated from here" } +STATIC_ASSERT((has_postdecrement::value)); // { dg-error "instantiated from here" } + diff --git a/gcc/testsuite/g++.dg/template/sfinae11.C b/gcc/testsuite/g++.dg/template/sfinae11.C new file mode 100644 index 00000000000..a813055ead2 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae11.C @@ -0,0 +1,53 @@ +// DR 339 +// +// Test of the use of the comma operator with SFINAE + +// Boilerplate helpers +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); +template struct type { }; + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +#define JOIN( X, Y ) DO_JOIN( X, Y ) +#define DO_JOIN( X, Y ) DO_JOIN2(X,Y) +#define DO_JOIN2( X, Y ) X##Y + +template + typename enable_if<(sizeof(create_a(), create_a()) > 0), + yes_type>::type + check_comma(int); + +template no_type check_comma(...); + +template +struct has_comma +{ + static const bool value = + (sizeof(check_comma(0)) == sizeof(yes_type)); +}; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) +#else +# define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] +#endif + +struct X { }; +struct Y { }; +struct Z { }; + +bool operator,(X&, Y); +bool operator,(X, Z); +void operator,(const Y&, const Z&); + +STATIC_ASSERT((has_comma::value)); +STATIC_ASSERT((has_comma::value)); +STATIC_ASSERT((has_comma::value)); +STATIC_ASSERT((has_comma::value)); +STATIC_ASSERT((has_comma::value)); +STATIC_ASSERT((has_comma::value)); +STATIC_ASSERT((!has_comma::value)); diff --git a/gcc/testsuite/g++.dg/template/sfinae12.C b/gcc/testsuite/g++.dg/template/sfinae12.C new file mode 100644 index 00000000000..c51211be2b9 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae12.C @@ -0,0 +1,47 @@ +// DR 339 +// +// Test of the use of the ternary operator with SFINAE + +// Boilerplate helpers +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); +template struct type { }; + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +#define JOIN( X, Y ) DO_JOIN( X, Y ) +#define DO_JOIN( X, Y ) DO_JOIN2(X,Y) +#define DO_JOIN2( X, Y ) X##Y + +template +typename enable_if< + (sizeof((create_a()? create_a() : create_a()), 0) > 0), + yes_type>::type + check_ternary(int); + +template no_type check_ternary(...); + +template +struct has_ternary +{ + static const bool value = + (sizeof(check_ternary(0)) == sizeof(yes_type)); +}; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) +#else +# define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] +#endif + +struct X { }; +struct Y { operator bool(); }; + +STATIC_ASSERT((has_ternary::value)); +STATIC_ASSERT((has_ternary::value)); +STATIC_ASSERT((!has_ternary::value)); +STATIC_ASSERT((!has_ternary::value)); +STATIC_ASSERT((has_ternary::value)); diff --git a/gcc/testsuite/g++.dg/template/sfinae13.C b/gcc/testsuite/g++.dg/template/sfinae13.C new file mode 100644 index 00000000000..b659685d88b --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae13.C @@ -0,0 +1,86 @@ +// DR 339 +// +// Test of the use of casts with SFINAE + +// Boilerplate helpers +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); +template struct type { }; + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +#define JOIN( X, Y ) DO_JOIN( X, Y ) +#define DO_JOIN( X, Y ) DO_JOIN2(X,Y) +#define DO_JOIN2( X, Y ) X##Y + +#define CHECK_CAST(CastKind) \ +template \ + typename enable_if<(sizeof((JOIN(CastKind,_cast)(create_a())), 0) > 0), \ + yes_type>::type \ + JOIN(check_,JOIN(CastKind,_cast))(int); \ + \ +template \ + no_type JOIN(check_,JOIN(CastKind,_cast))(...); \ + \ +template \ +struct JOIN(has_,JOIN(CastKind,_cast)) \ +{ \ + static const bool value = \ + (sizeof(JOIN(check_,JOIN(CastKind,_cast))(0)) == sizeof(yes_type)); \ +} + +template +typename enable_if<(sizeof(((U)create_a()), 0) > 0), yes_type>::type + check_c_cast(int); + +template no_type check_c_cast(...); + +template +struct has_c_cast +{ + static const bool value = + (sizeof(check_c_cast(0)) == sizeof(yes_type)); +}; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) +#else +# define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] +#endif + +CHECK_CAST(static); +CHECK_CAST(dynamic); +CHECK_CAST(const); +CHECK_CAST(reinterpret); + +struct X { virtual void f(); }; +struct Y { operator bool(); }; +struct Z : public X { }; + +STATIC_ASSERT((has_static_cast::value)); +STATIC_ASSERT((!has_static_cast::value)); +STATIC_ASSERT((has_static_cast::value)); + +STATIC_ASSERT(!(has_dynamic_cast::value)); +STATIC_ASSERT(!(has_dynamic_cast::value)); +STATIC_ASSERT(!(has_dynamic_cast::value)); +STATIC_ASSERT(!(has_dynamic_cast::value)); +STATIC_ASSERT((has_dynamic_cast::value)); +STATIC_ASSERT((has_dynamic_cast::value)); +STATIC_ASSERT(!(has_dynamic_cast::value)); + +STATIC_ASSERT(!(has_const_cast::value)); +STATIC_ASSERT((has_const_cast::value)); +STATIC_ASSERT((has_const_cast::value)); +STATIC_ASSERT(!(has_const_cast::value)); + +STATIC_ASSERT((has_reinterpret_cast::value)); +STATIC_ASSERT(!(has_reinterpret_cast::value)); +STATIC_ASSERT(!(has_reinterpret_cast::value)); + +STATIC_ASSERT((has_c_cast::value)); +STATIC_ASSERT(!(has_c_cast::value)); +STATIC_ASSERT(!(has_c_cast::value)); diff --git a/gcc/testsuite/g++.dg/template/sfinae14.C b/gcc/testsuite/g++.dg/template/sfinae14.C new file mode 100644 index 00000000000..93eba43a08f --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae14.C @@ -0,0 +1,79 @@ +// DR 339 +// +// Test of the use of the new and new[] operators with SFINAE + +// Boilerplate helpers +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); +template struct type { }; + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +#define JOIN( X, Y ) DO_JOIN( X, Y ) +#define DO_JOIN( X, Y ) DO_JOIN2(X,Y) +#define DO_JOIN2( X, Y ) X##Y + +template +typename enable_if<(sizeof(new T, 0) > 0), yes_type>::type + check_new(int); + +template no_type check_new(...); + +template +struct has_new +{ + static const bool value = + (sizeof(check_new(0)) == sizeof(yes_type)); +}; + +template +typename enable_if<(sizeof((new T(create_a())), 0) > 0), + yes_type>::type + check_new_one_arg(int); + +template no_type check_new_one_arg(...); + +template +struct has_new_one_arg +{ + static const bool value = + (sizeof(check_new_one_arg(0)) == sizeof(yes_type)); +}; + +template +typename enable_if<(sizeof(new T[N], 0) > 0), yes_type>::type + check_array_new(int); + +template no_type check_array_new(...); + +template +struct has_array_new +{ + static const bool value = + (sizeof(check_array_new(0)) == sizeof(yes_type)); +}; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) +#else +# define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] +#endif + +struct X { + X(int); +}; + +struct Y { int foo; }; + +STATIC_ASSERT((has_new::value)); +STATIC_ASSERT(!(has_new::value)); +STATIC_ASSERT((has_new_one_arg::value)); +STATIC_ASSERT((has_new_one_arg::value)); +STATIC_ASSERT(!(has_new_one_arg::value)); + +STATIC_ASSERT((has_array_new::value)); +STATIC_ASSERT(!(has_array_new::value)); +STATIC_ASSERT((has_array_new::value)); diff --git a/gcc/testsuite/g++.dg/template/sfinae4.C b/gcc/testsuite/g++.dg/template/sfinae4.C new file mode 100644 index 00000000000..a9650511e9d --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae4.C @@ -0,0 +1,35 @@ +// DR 339 +// +// Test of the use of free functions with SFINAE +void foo(int) { } +template void foo(T*) { } + +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +template + typename enable_if<(sizeof(foo(create_a()), 1) > 0), + yes_type>::type + check_has_foo(const volatile T&); + +no_type check_has_foo(...); + +template +struct has_foo +{ + static const bool value = + (sizeof(check_has_foo(create_a())) == sizeof(yes_type)); +}; + +struct X { }; + +int a1[has_foo::value? 1 : -1]; +int a2[has_foo::value? 1 : -1]; +int a3[has_foo::value? 1 : -1]; +int a4[has_foo::value? -1 : 1]; +int a5[has_foo::value? -1 : 1]; diff --git a/gcc/testsuite/g++.dg/template/sfinae5.C b/gcc/testsuite/g++.dg/template/sfinae5.C new file mode 100644 index 00000000000..516e5cc85fc --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae5.C @@ -0,0 +1,47 @@ +// DR 339 +// +// Test of the use of member functions with SFINAE +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +template + typename enable_if<(sizeof(create_a().foo(), 1) > 0), + yes_type>::type + check_has_member_foo(const volatile T&); + +no_type check_has_member_foo(...); + +template +struct has_foo +{ + static const bool value = + (sizeof(check_has_member_foo(create_a())) == sizeof(yes_type)); +}; + +struct X { }; +struct Y { + void foo(); +}; +struct Z { + void foo(int); +}; + +struct A { + int foo; +}; + +struct B { + static int foo(); +}; + +int a1[has_foo::value? -1 : 1]; +int a2[has_foo::value? 1 : -1]; +int a3[has_foo::value? -1 : 1]; +int a4[has_foo::value? -1 : 1]; +int a5[has_foo::value? -1 : 1]; +int a6[has_foo::value? 1 : -1]; diff --git a/gcc/testsuite/g++.dg/template/sfinae6.C b/gcc/testsuite/g++.dg/template/sfinae6.C new file mode 100644 index 00000000000..64567aae28e --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae6.C @@ -0,0 +1,83 @@ +// DR 339 +// +// Test of the use of the function call operator with SFINAE +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); + +template struct type { }; + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +template + typename enable_if()(create_a(), create_a()), 1), + yes_type>::type + check_is_callable2(type, type, type); + +no_type check_is_callable2(...); + +template +struct is_callable2 +{ + static const bool value = + (sizeof(check_is_callable2(type(), type(), type())) + == sizeof(yes_type)); +}; + +#define JOIN( X, Y ) DO_JOIN( X, Y ) +#define DO_JOIN( X, Y ) DO_JOIN2(X,Y) +#define DO_JOIN2( X, Y ) X##Y + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) +#else +# define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] +#endif + + +struct A; +struct B; + +struct A { + A(B); +}; + +struct B { + B(A); +}; + +struct F1 { }; + +struct F2 { + bool operator()(int, float); +}; + +struct F3 { + bool operator()(int); +}; + +struct F4 { + void operator()(A, A); + void operator()(B, B); +}; + +struct F5 { + void operator()(A, A); + +private: + void operator()(B, B); +}; + +STATIC_ASSERT((is_callable2::value)); +STATIC_ASSERT((!is_callable2::value)); +STATIC_ASSERT((!is_callable2::value)); +STATIC_ASSERT((is_callable2::value)); +STATIC_ASSERT((!is_callable2::value)); +STATIC_ASSERT((!is_callable2::value)); +STATIC_ASSERT((is_callable2::value)); +STATIC_ASSERT((is_callable2::value)); +STATIC_ASSERT((!is_callable2::value)); +STATIC_ASSERT((is_callable2::value)); +STATIC_ASSERT((!is_callable2::value)); diff --git a/gcc/testsuite/g++.dg/template/sfinae6_neg.C b/gcc/testsuite/g++.dg/template/sfinae6_neg.C new file mode 100644 index 00000000000..2df4ade4720 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae6_neg.C @@ -0,0 +1,58 @@ +// DR 339 +// +// Test of the use of the function call operator with SFINAE +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); + +template struct type { }; + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +template + typename enable_if()(create_a(), create_a()), 1), + yes_type>::type + check_is_callable2(type, type, type); + +no_type check_is_callable2(...); + +template +struct is_callable2 +{ + static const bool value = + (sizeof(check_is_callable2(type(), type(), type())) + == sizeof(yes_type)); // { dg-error "within this context" } +}; + +#define JOIN( X, Y ) DO_JOIN( X, Y ) +#define DO_JOIN( X, Y ) DO_JOIN2(X,Y) +#define DO_JOIN2( X, Y ) X##Y + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) +#else +# define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] +#endif + + +struct A; +struct B; + +struct A { + A(B); +}; + +struct B { + B(A); +}; + +struct F { + void operator()(A, A); + +private: + void operator()(B, B); // { dg-error "is private" } +}; + +STATIC_ASSERT((is_callable2::value)); diff --git a/gcc/testsuite/g++.dg/template/sfinae7.C b/gcc/testsuite/g++.dg/template/sfinae7.C new file mode 100644 index 00000000000..8551eb279fe --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae7.C @@ -0,0 +1,199 @@ +// DR 339 +// +// Test of the use of various binary operators with SFINAE + +// Boilerplate helpers +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); +template struct type { }; + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +#define JOIN( X, Y ) DO_JOIN( X, Y ) +#define DO_JOIN( X, Y ) DO_JOIN2(X,Y) +#define DO_JOIN2( X, Y ) X##Y + +#define DEFINE_INFIX_BINARY_TRAIT(Name,Op) \ +template \ + typename enable_if<(sizeof(create_a() Op create_a(), 1) > 0), \ + yes_type>::type \ + JOIN(check_,Name)(type, type); \ + \ +no_type JOIN(check_,Name)(...); \ + \ +template \ +struct Name \ +{ \ + static const bool value = \ + (sizeof(JOIN(check_,Name)(type(), type())) == sizeof(yes_type)); \ +} + +template + typename enable_if<(sizeof(create_a()[create_a()], 1) > 0), + yes_type>::type + check_subscript(int); + +template + no_type check_subscript(...); + +template +struct can_subscript +{ + static const bool value = + (sizeof(check_subscript(0)) == sizeof(yes_type)); +}; + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) +#else +# define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] +#endif + +struct X { }; +struct Y { int operator[](X); }; + +// is_addable +DEFINE_INFIX_BINARY_TRAIT(is_addable, +); +X operator+(X, X); +X operator+(X, Y); +STATIC_ASSERT((is_addable::value)); +STATIC_ASSERT((is_addable::value)); +STATIC_ASSERT((is_addable::value)); +STATIC_ASSERT((is_addable::value)); +STATIC_ASSERT((!is_addable::value)); +STATIC_ASSERT((is_addable::value)); +STATIC_ASSERT((!is_addable::value)); + +// is_subtractable +DEFINE_INFIX_BINARY_TRAIT(is_subtractable, -); +X operator-(X, X); +X operator-(X, Y); +STATIC_ASSERT((is_subtractable::value)); +STATIC_ASSERT((is_subtractable::value)); +STATIC_ASSERT((is_subtractable::value)); +STATIC_ASSERT((is_subtractable::value)); +STATIC_ASSERT((is_subtractable::value)); +STATIC_ASSERT((is_subtractable::value)); +STATIC_ASSERT((!is_subtractable::value)); +STATIC_ASSERT((!is_subtractable::value)); + +// is_multiplicable +DEFINE_INFIX_BINARY_TRAIT(is_multiplicable, *); +X operator*(X, X); +X operator*(X, Y); +STATIC_ASSERT((is_multiplicable::value)); +STATIC_ASSERT((is_multiplicable::value)); +STATIC_ASSERT((is_multiplicable::value)); +STATIC_ASSERT((!is_multiplicable::value)); +STATIC_ASSERT((!is_multiplicable::value)); +STATIC_ASSERT((is_multiplicable::value)); +STATIC_ASSERT((!is_multiplicable::value)); +STATIC_ASSERT((!is_multiplicable::value)); + +// is_divisible +DEFINE_INFIX_BINARY_TRAIT(is_divisible, /); +X operator/(X, X); +X operator/(X, Y); +STATIC_ASSERT((is_divisible::value)); +STATIC_ASSERT((is_divisible::value)); +STATIC_ASSERT((is_divisible::value)); +STATIC_ASSERT((!is_divisible::value)); +STATIC_ASSERT((!is_divisible::value)); +STATIC_ASSERT((is_divisible::value)); +STATIC_ASSERT((!is_divisible::value)); +STATIC_ASSERT((!is_divisible::value)); + +// has_remainder +DEFINE_INFIX_BINARY_TRAIT(has_remainder, %); +X operator%(X, X); +X operator%(X, Y); +STATIC_ASSERT((has_remainder::value)); +STATIC_ASSERT((has_remainder::value)); +STATIC_ASSERT((!has_remainder::value)); +STATIC_ASSERT((has_remainder::value)); +STATIC_ASSERT((!has_remainder::value)); +STATIC_ASSERT((!has_remainder::value)); +STATIC_ASSERT((has_remainder::value)); +STATIC_ASSERT((!has_remainder::value)); +STATIC_ASSERT((!has_remainder::value)); + +// has_xor +DEFINE_INFIX_BINARY_TRAIT(has_xor, ^); +X operator^(X, X); +X operator^(X, Y); +STATIC_ASSERT((has_xor::value)); +STATIC_ASSERT((has_xor::value)); +STATIC_ASSERT((!has_xor::value)); +STATIC_ASSERT((has_xor::value)); +STATIC_ASSERT((!has_xor::value)); +STATIC_ASSERT((!has_xor::value)); +STATIC_ASSERT((has_xor::value)); +STATIC_ASSERT((!has_xor::value)); +STATIC_ASSERT((!has_xor::value)); + +// has_bitand +DEFINE_INFIX_BINARY_TRAIT(has_bitand, &); +X operator&(X, X); +X operator&(X, Y); +STATIC_ASSERT((has_bitand::value)); +STATIC_ASSERT((has_bitand::value)); +STATIC_ASSERT((!has_bitand::value)); +STATIC_ASSERT((has_bitand::value)); +STATIC_ASSERT((!has_bitand::value)); +STATIC_ASSERT((!has_bitand::value)); +STATIC_ASSERT((has_bitand::value)); +STATIC_ASSERT((!has_bitand::value)); +STATIC_ASSERT((!has_bitand::value)); + +// has_bitor +DEFINE_INFIX_BINARY_TRAIT(has_bitor, |); +X operator|(X, X); +X operator|(X, Y); +STATIC_ASSERT((has_bitor::value)); +STATIC_ASSERT((has_bitor::value)); +STATIC_ASSERT((!has_bitor::value)); +STATIC_ASSERT((has_bitor::value)); +STATIC_ASSERT((!has_bitor::value)); +STATIC_ASSERT((!has_bitor::value)); +STATIC_ASSERT((has_bitor::value)); +STATIC_ASSERT((!has_bitor::value)); +STATIC_ASSERT((!has_bitor::value)); + +// has_left_shift +DEFINE_INFIX_BINARY_TRAIT(has_left_shift, <<); +X operator<<(X, X); +X operator<<(X, Y); +STATIC_ASSERT((has_left_shift::value)); +STATIC_ASSERT((has_left_shift::value)); +STATIC_ASSERT((!has_left_shift::value)); +STATIC_ASSERT((has_left_shift::value)); +STATIC_ASSERT((!has_left_shift::value)); +STATIC_ASSERT((!has_left_shift::value)); +STATIC_ASSERT((has_left_shift::value)); +STATIC_ASSERT((!has_left_shift::value)); +STATIC_ASSERT((!has_left_shift::value)); + +// has_right_shift +DEFINE_INFIX_BINARY_TRAIT(has_right_shift, >>); +X operator>>(X, X); +X operator>>(X, Y); +STATIC_ASSERT((has_right_shift::value)); +STATIC_ASSERT((has_right_shift::value)); +STATIC_ASSERT((!has_right_shift::value)); +STATIC_ASSERT((has_right_shift::value)); +STATIC_ASSERT((!has_right_shift::value)); +STATIC_ASSERT((!has_right_shift::value)); +STATIC_ASSERT((has_right_shift::value)); +STATIC_ASSERT((!has_right_shift::value)); +STATIC_ASSERT((!has_right_shift::value)); + +// can_subscript +STATIC_ASSERT((can_subscript::value)); +STATIC_ASSERT((can_subscript::value)); +STATIC_ASSERT((can_subscript::value)); +STATIC_ASSERT((can_subscript::value)); +STATIC_ASSERT((!can_subscript::value)); +STATIC_ASSERT((can_subscript::value)); diff --git a/gcc/testsuite/g++.dg/template/sfinae8.C b/gcc/testsuite/g++.dg/template/sfinae8.C new file mode 100644 index 00000000000..2ad68dc5dbf --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae8.C @@ -0,0 +1,182 @@ +// DR 339 +// +// Test of the use of various boolean binary operators with SFINAE + +// Boilerplate helpers +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); +template struct type { }; + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +#define JOIN( X, Y ) DO_JOIN( X, Y ) +#define DO_JOIN( X, Y ) DO_JOIN2(X,Y) +#define DO_JOIN2( X, Y ) X##Y + +bool accepts_bool(bool); + +#define DEFINE_BINARY_PREDICATE_TRAIT(Name,Op) \ +template \ + typename enable_if() Op create_a())), \ + yes_type>::type \ + JOIN(check_,Name)(type, type); \ + \ +no_type JOIN(check_,Name)(...); \ + \ +template \ +struct Name \ +{ \ + static const bool value = \ + (sizeof(JOIN(check_,Name)(type(), type())) == sizeof(yes_type)); \ +} + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) +#else +# define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] +#endif + +struct X { }; +struct Y { }; + +struct convertible_to_bool { + operator int convertible_to_bool::* (); +}; + +struct not_convertible_to_bool { }; + +// is_less_than_comparable +DEFINE_BINARY_PREDICATE_TRAIT(is_less_than_comparable,<); +bool operator<(X, X); +convertible_to_bool operator<(X, Y); +not_convertible_to_bool operator<(Y, X); + +STATIC_ASSERT((is_less_than_comparable::value)); +STATIC_ASSERT((is_less_than_comparable::value)); +STATIC_ASSERT((is_less_than_comparable::value)); +STATIC_ASSERT((is_less_than_comparable::value)); +STATIC_ASSERT((is_less_than_comparable::value)); +STATIC_ASSERT((!is_less_than_comparable::value)); +STATIC_ASSERT((!is_less_than_comparable::value)); + +// is_less_equal_comparable +DEFINE_BINARY_PREDICATE_TRAIT(is_less_equal_comparable,<=); +bool operator<=(X, X); +convertible_to_bool operator<=(X, Y); +not_convertible_to_bool operator<=(Y, X); + +STATIC_ASSERT((is_less_equal_comparable::value)); +STATIC_ASSERT((is_less_equal_comparable::value)); +STATIC_ASSERT((is_less_equal_comparable::value)); +STATIC_ASSERT((is_less_equal_comparable::value)); +STATIC_ASSERT((is_less_equal_comparable::value)); +STATIC_ASSERT((!is_less_equal_comparable::value)); +STATIC_ASSERT((!is_less_equal_comparable::value)); + +// is_greater_than_comparable +DEFINE_BINARY_PREDICATE_TRAIT(is_greater_than_comparable,>); +bool operator>(X, X); +convertible_to_bool operator>(X, Y); +not_convertible_to_bool operator>(Y, X); + +STATIC_ASSERT((is_greater_than_comparable::value)); +STATIC_ASSERT((is_greater_than_comparable::value)); +STATIC_ASSERT((is_greater_than_comparable::value)); +STATIC_ASSERT((is_greater_than_comparable::value)); +STATIC_ASSERT((is_greater_than_comparable::value)); +STATIC_ASSERT((!is_greater_than_comparable::value)); +STATIC_ASSERT((!is_greater_than_comparable::value)); + +// is_greater_equal_comparable +DEFINE_BINARY_PREDICATE_TRAIT(is_greater_equal_comparable,>=); +bool operator>=(X, X); +convertible_to_bool operator>=(X, Y); +not_convertible_to_bool operator>=(Y, X); + +STATIC_ASSERT((is_greater_equal_comparable::value)); +STATIC_ASSERT((is_greater_equal_comparable::value)); +STATIC_ASSERT((is_greater_equal_comparable::value)); +STATIC_ASSERT((is_greater_equal_comparable::value)); +STATIC_ASSERT((is_greater_equal_comparable::value)); +STATIC_ASSERT((!is_greater_equal_comparable::value)); +STATIC_ASSERT((!is_greater_equal_comparable::value)); + +// is_equality_comparable +struct Z : X { }; +DEFINE_BINARY_PREDICATE_TRAIT(is_equality_comparable,==); +bool operator==(X, X); +convertible_to_bool operator==(X, Y); +not_convertible_to_bool operator==(Y, X); + +STATIC_ASSERT((is_equality_comparable::value)); +STATIC_ASSERT((is_equality_comparable::value)); +STATIC_ASSERT((is_equality_comparable::value)); +STATIC_ASSERT((is_equality_comparable::value)); +STATIC_ASSERT((is_equality_comparable::value)); +STATIC_ASSERT((!is_equality_comparable::value)); +STATIC_ASSERT((!is_equality_comparable::value)); +STATIC_ASSERT((is_equality_comparable::value)); +STATIC_ASSERT((!is_equality_comparable::value)); +STATIC_ASSERT((is_equality_comparable::value)); +STATIC_ASSERT((is_equality_comparable::value)); +STATIC_ASSERT((!is_equality_comparable::value)); + +// is_not_equal_comparable +DEFINE_BINARY_PREDICATE_TRAIT(is_not_equal_comparable,!=); +bool operator!=(X, X); +convertible_to_bool operator!=(X, Y); +not_convertible_to_bool operator!=(Y, X); + +STATIC_ASSERT((is_not_equal_comparable::value)); +STATIC_ASSERT((is_not_equal_comparable::value)); +STATIC_ASSERT((is_not_equal_comparable::value)); +STATIC_ASSERT((is_not_equal_comparable::value)); +STATIC_ASSERT((is_not_equal_comparable::value)); +STATIC_ASSERT((!is_not_equal_comparable::value)); +STATIC_ASSERT((!is_not_equal_comparable::value)); +STATIC_ASSERT((is_not_equal_comparable::value)); +STATIC_ASSERT((!is_not_equal_comparable::value)); +STATIC_ASSERT((is_not_equal_comparable::value)); +STATIC_ASSERT((is_not_equal_comparable::value)); +STATIC_ASSERT((!is_not_equal_comparable::value)); + +// has_logical_and +DEFINE_BINARY_PREDICATE_TRAIT(has_logical_and,&&); +bool operator&&(X, X); +convertible_to_bool operator&&(X, Y); +not_convertible_to_bool operator&&(Y, X); + +STATIC_ASSERT((has_logical_and::value)); +STATIC_ASSERT((has_logical_and::value)); +STATIC_ASSERT((has_logical_and::value)); +STATIC_ASSERT((has_logical_and::value)); +STATIC_ASSERT((has_logical_and::value)); +STATIC_ASSERT((!has_logical_and::value)); +STATIC_ASSERT((!has_logical_and::value)); +STATIC_ASSERT((has_logical_and::value)); +STATIC_ASSERT((has_logical_and::value)); +STATIC_ASSERT((has_logical_and::value)); +STATIC_ASSERT((has_logical_and::value)); +STATIC_ASSERT((has_logical_and::value)); + +// has_logical_or +DEFINE_BINARY_PREDICATE_TRAIT(has_logical_or,||); +bool operator||(X, X); +convertible_to_bool operator||(X, Y); +not_convertible_to_bool operator||(Y, X); + +STATIC_ASSERT((has_logical_or::value)); +STATIC_ASSERT((has_logical_or::value)); +STATIC_ASSERT((has_logical_or::value)); +STATIC_ASSERT((has_logical_or::value)); +STATIC_ASSERT((has_logical_or::value)); +STATIC_ASSERT((!has_logical_or::value)); +STATIC_ASSERT((!has_logical_or::value)); +STATIC_ASSERT((has_logical_or::value)); +STATIC_ASSERT((has_logical_or::value)); +STATIC_ASSERT((has_logical_or::value)); +STATIC_ASSERT((has_logical_or::value)); +STATIC_ASSERT((has_logical_or::value)); diff --git a/gcc/testsuite/g++.dg/template/sfinae9.C b/gcc/testsuite/g++.dg/template/sfinae9.C new file mode 100644 index 00000000000..4e27ff61bd5 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/sfinae9.C @@ -0,0 +1,207 @@ +// DR 339 +// +// Test of the use of various assignment operators with SFINAE + +// Boilerplate helpers +typedef char yes_type; +struct no_type { char data[2]; }; + +template T create_a(); +template struct type { }; + +template struct enable_if { typedef T type; }; +template struct enable_if { }; + +#define JOIN( X, Y ) DO_JOIN( X, Y ) +#define DO_JOIN( X, Y ) DO_JOIN2(X,Y) +#define DO_JOIN2( X, Y ) X##Y + +#define DEFINE_INFIX_BINARY_TRAIT(Name,Op) \ +template \ + typename enable_if<(sizeof(create_a() Op create_a(), 1) > 0), \ + yes_type>::type \ + JOIN(check_,Name)(type, type); \ + \ +no_type JOIN(check_,Name)(...); \ + \ +template \ +struct Name \ +{ \ + static const bool value = \ + (sizeof(JOIN(check_,Name)(type(), type())) == sizeof(yes_type)); \ +} + +#ifdef __GXX_EXPERIMENTAL_CXX0X__ +# define STATIC_ASSERT(Expr) static_assert(Expr, #Expr) +#else +# define STATIC_ASSERT(Expr) int JOIN(a,__LINE__)[Expr? 1 : -1] +#endif + +struct Y { + Y& operator=(Y&); +}; + +struct X { + X& operator=(Y); + X& operator+=(X); + X& operator-=(X); + X& operator*=(X); + X& operator/=(X); + X& operator%=(X); + X& operator^=(X); + X& operator&=(X); + X& operator|=(X); + X& operator<<=(X); + X& operator>>=(X); +}; +struct Z { }; + +// is_assignable +DEFINE_INFIX_BINARY_TRAIT(is_assignable, =); +STATIC_ASSERT((is_assignable::value)); +STATIC_ASSERT((is_assignable::value)); +STATIC_ASSERT((is_assignable::value)); +STATIC_ASSERT((!is_assignable::value)); +STATIC_ASSERT((is_assignable::value)); +STATIC_ASSERT((is_assignable::value)); +STATIC_ASSERT((!is_assignable::value)); +STATIC_ASSERT((!is_assignable::value)); +STATIC_ASSERT((!is_assignable::value)); + +// has_plus_assign +DEFINE_INFIX_BINARY_TRAIT(has_plus_assign, +=); +X& operator+=(X&, Y); +STATIC_ASSERT((has_plus_assign::value)); +STATIC_ASSERT((has_plus_assign::value)); +STATIC_ASSERT((has_plus_assign::value)); +STATIC_ASSERT((has_plus_assign::value)); +STATIC_ASSERT((!has_plus_assign::value)); +STATIC_ASSERT((has_plus_assign::value)); +STATIC_ASSERT((!has_plus_assign::value)); +STATIC_ASSERT((!has_plus_assign::value)); +STATIC_ASSERT((!has_plus_assign::value)); + +// has_minus_assign +DEFINE_INFIX_BINARY_TRAIT(has_minus_assign, -=); +X& operator-=(X&, Y); +STATIC_ASSERT((has_minus_assign::value)); +STATIC_ASSERT((has_minus_assign::value)); +STATIC_ASSERT((has_minus_assign::value)); +STATIC_ASSERT((has_minus_assign::value)); +STATIC_ASSERT((!has_minus_assign::value)); +STATIC_ASSERT((has_minus_assign::value)); +STATIC_ASSERT((!has_minus_assign::value)); +STATIC_ASSERT((!has_minus_assign::value)); +STATIC_ASSERT((!has_minus_assign::value)); +STATIC_ASSERT((!has_minus_assign::value)); + +// has_multiply_assign +DEFINE_INFIX_BINARY_TRAIT(has_multiply_assign, *=); +X& operator*=(X&, Y); +STATIC_ASSERT((has_multiply_assign::value)); +STATIC_ASSERT((has_multiply_assign::value)); +STATIC_ASSERT((has_multiply_assign::value)); +STATIC_ASSERT((!has_multiply_assign::value)); +STATIC_ASSERT((!has_multiply_assign::value)); +STATIC_ASSERT((has_multiply_assign::value)); +STATIC_ASSERT((!has_multiply_assign::value)); +STATIC_ASSERT((!has_multiply_assign::value)); +STATIC_ASSERT((!has_multiply_assign::value)); +STATIC_ASSERT((!has_multiply_assign::value)); + +// has_divide_assign +DEFINE_INFIX_BINARY_TRAIT(has_divide_assign, /=); +X& operator/=(X&, Y); +STATIC_ASSERT((has_divide_assign::value)); +STATIC_ASSERT((has_divide_assign::value)); +STATIC_ASSERT((has_divide_assign::value)); +STATIC_ASSERT((!has_divide_assign::value)); +STATIC_ASSERT((!has_divide_assign::value)); +STATIC_ASSERT((has_divide_assign::value)); +STATIC_ASSERT((!has_divide_assign::value)); +STATIC_ASSERT((!has_divide_assign::value)); +STATIC_ASSERT((!has_divide_assign::value)); + +// has_remainder_assign +DEFINE_INFIX_BINARY_TRAIT(has_remainder_assign, %=); +X& operator%=(X&, Y); +STATIC_ASSERT((has_remainder_assign::value)); +STATIC_ASSERT((has_remainder_assign::value)); +STATIC_ASSERT((!has_remainder_assign::value)); +STATIC_ASSERT((has_remainder_assign::value)); +STATIC_ASSERT((!has_remainder_assign::value)); +STATIC_ASSERT((!has_remainder_assign::value)); +STATIC_ASSERT((has_remainder_assign::value)); +STATIC_ASSERT((!has_remainder_assign::value)); +STATIC_ASSERT((!has_remainder_assign::value)); +STATIC_ASSERT((!has_remainder_assign::value)); + +// has_xor_assign +DEFINE_INFIX_BINARY_TRAIT(has_xor_assign, ^=); +X& operator^=(X&, Y); +STATIC_ASSERT((has_xor_assign::value)); +STATIC_ASSERT((has_xor_assign::value)); +STATIC_ASSERT((!has_xor_assign::value)); +STATIC_ASSERT((has_xor_assign::value)); +STATIC_ASSERT((!has_xor_assign::value)); +STATIC_ASSERT((!has_xor_assign::value)); +STATIC_ASSERT((has_xor_assign::value)); +STATIC_ASSERT((!has_xor_assign::value)); +STATIC_ASSERT((!has_xor_assign::value)); +STATIC_ASSERT((!has_xor_assign::value)); + +// has_bitand_assign +DEFINE_INFIX_BINARY_TRAIT(has_bitand_assign, &=); +X& operator&=(X&, Y); +STATIC_ASSERT((has_bitand_assign::value)); +STATIC_ASSERT((has_bitand_assign::value)); +STATIC_ASSERT((!has_bitand_assign::value)); +STATIC_ASSERT((has_bitand_assign::value)); +STATIC_ASSERT((!has_bitand_assign::value)); +STATIC_ASSERT((!has_bitand_assign::value)); +STATIC_ASSERT((has_bitand_assign::value)); +STATIC_ASSERT((!has_bitand_assign::value)); +STATIC_ASSERT((!has_bitand_assign::value)); +STATIC_ASSERT((!has_bitand_assign::value)); + +// has_bitor_assign +DEFINE_INFIX_BINARY_TRAIT(has_bitor_assign, |=); +X& operator|=(X&, Y); +STATIC_ASSERT((has_bitor_assign::value)); +STATIC_ASSERT((has_bitor_assign::value)); +STATIC_ASSERT((!has_bitor_assign::value)); +STATIC_ASSERT((has_bitor_assign::value)); +STATIC_ASSERT((!has_bitor_assign::value)); +STATIC_ASSERT((!has_bitor_assign::value)); +STATIC_ASSERT((has_bitor_assign::value)); +STATIC_ASSERT((!has_bitor_assign::value)); +STATIC_ASSERT((!has_bitor_assign::value)); +STATIC_ASSERT((!has_bitor_assign::value)); + +// has_left_shift_assign +DEFINE_INFIX_BINARY_TRAIT(has_left_shift_assign, <<=); +X& operator<<=(X&, Y); +STATIC_ASSERT((has_left_shift_assign::value)); +STATIC_ASSERT((has_left_shift_assign::value)); +STATIC_ASSERT((!has_left_shift_assign::value)); +STATIC_ASSERT((has_left_shift_assign::value)); +STATIC_ASSERT((!has_left_shift_assign::value)); +STATIC_ASSERT((!has_left_shift_assign::value)); +STATIC_ASSERT((has_left_shift_assign::value)); +STATIC_ASSERT((!has_left_shift_assign::value)); +STATIC_ASSERT((!has_left_shift_assign::value)); +STATIC_ASSERT((!has_left_shift_assign::value)); + +// has_right_shift_assign +DEFINE_INFIX_BINARY_TRAIT(has_right_shift_assign, >>=); +X& operator>>=(X&, Y); +STATIC_ASSERT((has_right_shift_assign::value)); +STATIC_ASSERT((has_right_shift_assign::value)); +STATIC_ASSERT((!has_right_shift_assign::value)); +STATIC_ASSERT((has_right_shift_assign::value)); +STATIC_ASSERT((!has_right_shift_assign::value)); +STATIC_ASSERT((!has_right_shift_assign::value)); +STATIC_ASSERT((has_right_shift_assign::value)); +STATIC_ASSERT((!has_right_shift_assign::value)); +STATIC_ASSERT((!has_right_shift_assign::value)); +STATIC_ASSERT((!has_right_shift_assign::value));