Lines Matching defs:complain
269 build_addr_func (tree function, tsubst_flags_t complain)
282 complain);
290 function = decay_conversion (function, complain, /*reject_builtin=*/false);
827 build_list_conv (tree type, tree ctor, int flags, tsubst_flags_t complain)
852 false, flags, complain);
908 can_convert_array (tree atype, tree from, int flags, tsubst_flags_t complain)
920 ok = can_convert_array (elttype, val, flags, complain);
923 complain);
964 build_aggr_conv (tree type, tree ctor, int flags, tsubst_flags_t complain)
993 ok = can_convert_array (ftype, val, flags, complain);
996 complain);
1028 val = get_nsdmi (field, /*ctor*/false, complain);
1040 ok = can_convert_array (ftype, val, flags, complain);
1043 complain);
1068 build_array_conv (tree type, tree ctor, int flags, tsubst_flags_t complain)
1094 false, flags, complain);
1120 tsubst_flags_t complain)
1138 false, flags, complain);
1205 int flags, tsubst_flags_t complain)
1235 expr = resolve_nondeduced_context (expr, complain);
1285 complain);
1709 tsubst_flags_t complain)
1894 complain);
1944 flags, complain);
1967 sflags, complain);
2006 int flags, tsubst_flags_t complain)
2021 have 'complain &= ~(tf_warning|tf_error)' because it would cause
2025 complain &= ~tf_error;
2033 expr = reshape_init (to, expr, complain);
2040 conv = reference_binding (to, from, expr, c_cast_p, flags, complain);
2042 conv = standard_conversion (to, from, expr, c_cast_p, flags, complain);
2050 return build_list_conv (to, expr, flags, complain);
2056 conv = build_complex_conv (to, expr, flags, complain);
2076 c_cast_p, flags, complain);
2087 return build_array_conv (to, expr, flags, complain);
2100 return build_aggr_conv (to, expr, flags, complain);
2102 cand = build_user_type_conversion_1 (to, expr, flags, complain);
2119 c_cast_p, flags, complain);
2140 int flags, tsubst_flags_t complain)
2143 flags, complain);
2161 int flags, tsubst_flags_t complain)
2164 flags, complain);
2259 int flags, tsubst_flags_t complain)
2297 /*c_cast_p=*/false, flags, complain);
2325 tsubst_flags_t complain)
2472 flags, complain);
2477 /*c_cast_p=*/false, lflags, complain);
2529 tsubst_flags_t complain)
2576 /*c_cast_p=*/false, flags, complain);
2619 tree *argtypes, int flags, tsubst_flags_t complain)
2645 /*c_cast_p=*/false, flags, complain);
2671 complain);
2727 int flags, tsubst_flags_t complain)
3170 flags, complain);
3176 (candidates, fnname, type1, type1, args, argtypes, flags, complain);
3178 (candidates, fnname, type2, type2, args, argtypes, flags, complain);
3183 (candidates, fnname, type1, type2, args, argtypes, flags, complain);
3213 int flags, tsubst_flags_t complain)
3256 NULL_TREE, args, argtypes, flags, complain);
3263 boolean_type_node, args, argtypes, flags, complain);
3368 u, args, argtypes, flags, complain);
3372 NULL_TREE, args, argtypes, flags, complain);
3398 bool shortcut_bad_convs, tsubst_flags_t complain)
3544 flags, complain);
3559 false, complain & tf_decltype);
3597 access_path, conversion_path, complain);
3602 shortcut_bad_convs, complain);
3640 tsubst_flags_t complain)
3647 complain);
3661 tree conversion_path, tsubst_flags_t complain)
3673 /*shortcut_bad_convs=*/false, complain);
4073 tsubst_flags_t complain)
4097 access_path, flags, candidates, complain);
4104 if (complain & tf_error)
4125 access_path, flags, candidates, complain);
4136 tsubst_flags_t complain)
4187 complain |= tf_conv;
4212 ctorflags, &candidates, complain);
4218 ctorflags, &candidates, complain);
4282 flags, &candidates, complain);
4296 complain);
4373 cand = tourney (candidates, complain);
4376 if (complain & tf_error)
4441 tsubst_flags_t complain)
4447 cand = build_user_type_conversion_1 (totype, expr, flags, complain);
4455 expr = convert_like (cand->second_conv, expr, complain);
4470 tsubst_flags_t complain = tf_warning_or_error;
4475 instantiate_type (type, expr, complain);
4476 else if (invalid_nonstatic_memfn_p (loc, expr, complain))
4496 int flags, tsubst_flags_t complain)
4510 /*c_cast_p=*/false, flags, complain);
4536 complain later that the argument isn't constant. */
4553 if (complain & tf_error)
4574 if (complain & tf_error)
4607 expr = convert_like (conv, expr, complain);
4611 if (complain & tf_error)
4637 build_converted_constant_expr (tree type, tree expr, tsubst_flags_t complain)
4640 complain);
4648 build_converted_constant_bool_expr (tree expr, tsubst_flags_t complain)
4651 LOOKUP_NORMAL, complain);
4657 resolve_args (vec<tree, va_gc> *args, tsubst_flags_t complain)
4668 if (complain & tf_error)
4673 else if (invalid_nonstatic_memfn_p (EXPR_LOCATION (arg), arg, complain))
4678 if (!mark_single_function (arg, complain & ~tf_warning))
4700 bool *any_viable_p, tsubst_flags_t complain)
4730 candidates, complain);
4734 cand = tourney (*candidates, complain);
4778 tsubst_flags_t complain)
4790 &any_viable_p, complain);
4793 if (complain & tf_error)
4812 tsubst_flags_t complain)
4821 *args = resolve_args (*args, complain);
4833 complain);
4837 if (complain & tf_error)
4843 return cp_build_function_call_vec (candidates->fn, args, complain);
4852 result = build_over_call (cand, LOOKUP_NORMAL, complain);
4885 tree *fn, tsubst_flags_t complain)
4905 *args = resolve_args (*args, complain);
4935 complain);
4941 if (complain & tf_error)
4987 tree ret = build_over_call (cand, LOOKUP_NORMAL, complain);
5002 build_op_call (tree obj, vec<tree, va_gc> **args, tsubst_flags_t complain)
5023 if (complain & tf_error)
5033 fns = lookup_fnfields (TYPE_BINFO (type), call_op_identifier, 1, complain);
5042 *args = resolve_args (*args, complain);
5058 LOOKUP_NORMAL, &candidates, complain);
5080 /*conversion_path=*/NULL_TREE, complain);
5084 /*access_path=*/NULL_TREE, complain);
5093 if (complain & tf_error)
5104 cand = tourney (candidates, complain);
5107 if (complain & tf_error)
5119 result = build_over_call (cand, LOOKUP_NORMAL, complain);
5124 -1, complain);
5128 obj = convert_like (cand->convs[0], obj, complain);
5131 result = cp_build_function_call_vec (obj, args, complain);
5256 conditional_conversion (tree e1, tree e2, tsubst_flags_t complain)
5282 complain);
5326 LOOKUP_IMPLICIT, complain);
5335 tsubst_flags_t complain)
5355 if (complain & tf_error)
5360 if ((complain & tf_warning) && !truth_value_p (TREE_CODE (arg1)))
5397 arg1 = force_rvalue (arg1, complain);
5398 arg2 = force_rvalue (arg2, complain);
5399 arg3 = force_rvalue (arg3, complain);
5415 orig_arg2, orig_arg3, complain);
5423 if (complain & tf_error)
5434 /* We could pass complain & tf_warning to unsafe_conversion_p,
5440 if (complain & tf_error)
5447 if (complain & tf_error)
5453 arg2 = cp_convert (stype, arg2, complain);
5457 arg3 = cp_convert (stype, arg3, complain);
5468 complain & tf_error);
5502 if (complain & tf_error)
5522 arg1 = perform_implicit_conversion_flags (boolean_type_node, arg1, complain,
5542 arg2 = resolve_nondeduced_context_or_error (arg2, complain);
5547 arg3 = resolve_nondeduced_context_or_error (arg3, complain);
5580 if (complain & tf_error)
5619 conv2 = conditional_conversion (arg2, arg3, complain);
5620 conv3 = conditional_conversion (arg3, arg2, complain);
5636 if (complain & tf_error)
5644 convert_like (conv2, arg2, complain);
5646 convert_like (conv3, arg3, complain);
5652 arg2 = convert_like (conv2, arg2, complain);
5666 arg3 = convert_like (conv3, arg3, complain);
5743 LOOKUP_NORMAL, complain);
5752 if (complain & tf_error)
5757 cand = tourney (candidates, complain);
5760 if (complain & tf_error)
5775 arg1 = convert_like (conv, arg1, complain);
5777 arg2 = convert_like (conv, arg2, complain);
5780 arg3 = convert_like (conv, arg3, complain);
5795 arg2 = force_rvalue (arg2, complain);
5799 arg3 = force_rvalue (arg3, complain);
5827 if (complain & tf_warning)
5844 else if (complain & tf_warning)
5849 else if ((complain & tf_warning)
5874 if (complain & tf_warning)
5884 arg2 = perform_implicit_conversion (result_type, arg2, complain);
5885 arg3 = perform_implicit_conversion (result_type, arg3, complain);
5914 complain);
5917 arg2 = perform_implicit_conversion (result_type, arg2, complain);
5918 arg3 = perform_implicit_conversion (result_type, arg3, complain);
5923 if (complain & tf_error)
5945 && (complain & tf_warning)
5961 result = get_target_expr_sfinae (result, complain);
6069 tsubst_flags_t complain)
6104 and complain if one is chosen. */
6203 complain))
6218 complain);
6236 if (complain & (tf_error | tf_conv))
6325 int flags, tsubst_flags_t complain)
6372 flags, candidates, complain);
6381 tree fns = lookup_fnfields (arg1_type, fnname, 1, complain);
6390 flags, candidates, complain);
6440 flags, complain);
6471 arglist, lookups, flags, complain);
6481 revlist, lookups, flags, complain);
6500 tree *overload, tsubst_flags_t complain)
6594 lookups, flags, complain);
6625 if (!(complain & tf_error))
6650 NULL_TREE, lookups, overload, complain);
6663 if (complain & tf_error)
6687 cand = tourney (candidates, complain);
6690 if (complain & tf_error)
6705 if (resolve_args (arglist, complain) == NULL)
6709 tsubst_flags_t ocomplain = complain;
6766 if (complain & tf_error)
6808 NULL, complain);
6820 if (cand->warnings && (complain & tf_warning))
6824 joust (cand, w->loser, 1, complain);
6840 && (complain & tf_warning))
6858 arg1 = convert_like (conv, arg1, complain);
6867 arg2 = convert_like (conv, arg2, complain);
6877 arg3 = convert_like (conv, arg3, complain);
6895 return cp_build_modify_expr (loc, arg1, code2, arg2, complain);
6898 return cp_build_indirect_ref (loc, arg1, RO_UNARY_STAR, complain);
6904 if ((complain & tf_warning) && !processing_template_decl)
6915 if ((complain & tf_warning)
6919 if (complain & tf_warning && warn_tautological_compare)
6935 return cp_build_binary_op (loc, code, arg1, arg2, complain);
6949 return cp_build_unary_op (code, arg1, false, complain);
6952 return cp_build_array_ref (input_location, arg1, arg2, complain);
6957 complain),
6958 arg2, complain);
6977 tsubst_flags_t complain)
6999 1, complain);
7008 *args = resolve_args (*args, complain);
7024 LOOKUP_NORMAL, &candidates, complain);
7032 if (complain & tf_error)
7043 cand = tourney (candidates, complain);
7046 if (complain & tf_error)
7061 result = build_over_call (cand, LOOKUP_NORMAL, complain);
7259 tree alloc_fn, tsubst_flags_t complain)
7281 Therefore, we ask lookup_fnfields to complain about ambiguity. */
7283 fns = lookup_fnfields (TYPE_BINFO (type), fnname, 1, complain);
7295 addr = cp_convert (ptr_type_node, addr, complain);
7332 the usual deallocation function, so we shouldn't complain
7346 if (complain & tf_warning)
7355 if (complain & tf_warning_or_error)
7475 complain);
7492 if (!mark_used (fn, complain) && !(complain & tf_error))
7494 ret = build_cxx_call (fn, nargs, argarray, complain);
7506 addr = cp_convert (rtype, oaddr, complain);
7509 complain);
7523 ret = cp_build_function_call_vec (fn, &args, complain);
7546 alloc_fn, complain);
7555 if ((complain & tf_warning)
7570 if (complain & tf_error)
7634 diagnostic_t *diagnostic_kind, tsubst_flags_t complain)
7647 return get_target_expr_sfinae (expr, complain);
7655 expr = build_cplus_new (type, expr, complain);
7660 &args, type, flags, complain);
7837 tsubst_flags_t complain)
7844 if (convs->bad_p && !(complain & tf_error))
7893 /*c_cast_p=*/false, complain);
7897 complain);
7899 expr = cp_convert (totype, expr, complain);
7908 /*c_cast_p=*/false, complain);
7914 /*c_cast_p=*/false, complain);
7929 return cp_convert (totype, expr, complain);
7932 if (issue_conversion_warnings && (complain & tf_warning))
7945 LOOKUP_NO_CONVERSION, complain);
7958 if (!(complain & tf_error))
7983 if (abstract_virtuals_error_sfinae (NULL_TREE, totype, complain))
7985 expr = build_value_init (totype, complain);
7986 expr = get_target_expr_sfinae (expr, complain);
8002 complain);
8008 expr = build_cplus_new (totype, expr, complain);
8022 expr = build_value_init (totype, complain);
8033 expr = instantiate_type (totype, expr, complain);
8044 check complain here, too. */
8045 if (complain & tf_error)
8050 build_user_type_conversion (totype, convs->u.expr, flags, complain);
8073 argnum, false, false, complain);
8077 && !check_narrowing (TREE_TYPE (sub), val, complain))
8088 array = finish_compound_literal (array, new_ctor, complain);
8091 array = cp_build_addr_expr (array, complain);
8096 array = cp_convert (build_pointer_type (elttype), array, complain);
8103 totype = complete_type_or_maybe_complain (totype, NULL_TREE, complain);
8112 return get_target_expr_sfinae (new_ctor, complain);
8121 real, complain);
8123 imag, complain);
8127 expr = reshape_init (totype, expr, complain);
8128 expr = get_target_expr_sfinae (digest_init (totype, expr, complain),
8129 complain);
8149 c_cast_p, complain & ~tf_no_cleanup);
8156 expr = decay_conversion (expr, complain);
8159 if (complain & tf_error)
8191 !c_cast_p, /*nonnull=*/true, complain);
8213 expr = build_temp (expr, totype, flags, &diag_kind, complain);
8214 if (diag_kind && complain)
8221 return build_cplus_new (totype, expr, complain);
8276 else if (complain & tf_warning)
8302 if (complain & tf_error)
8343 expr = build_target_expr_with_type (expr, type, complain);
8348 expr = cp_build_addr_expr (expr, complain);
8356 expr, complain);
8362 return decay_conversion (expr, complain);
8371 if (complain & tf_warning)
8381 /*nonnull=*/false, complain);
8386 c_cast_p, complain);
8393 && !check_narrowing (totype, expr, complain,
8399 expr = cp_convert_and_check (totype, expr, complain);
8401 expr = cp_convert (totype, expr, complain);
8433 tsubst_flags_t complain)
8455 issue_conversion_warnings, c_cast_p, complain);
8464 convert_like (conversion *convs, tree expr, tsubst_flags_t complain)
8468 /*c_cast_p=*/false, complain);
8475 tsubst_flags_t complain)
8479 /*c_cast_p=*/false, complain);
8486 convert_arg_to_ellipsis (tree arg, tsubst_flags_t complain)
8503 if ((complain & tf_warning)
8518 arg = cp_build_compound_expr (arg, null_pointer_node, complain);
8528 complain);
8529 prom = cp_perform_integral_promotions (prom, complain);
8532 && (complain & tf_warning))
8541 arg = cp_perform_integral_promotions (arg, complain);
8548 arg = decay_conversion (arg, complain);
8550 arg = require_complete_type_sfinae (arg, complain);
8574 arg = force_rvalue (arg, complain);
8575 if (complain & tf_warning)
8585 force_rvalue (arg, complain);
8675 tsubst_flags_t complain)
8690 if (complain & tf_error)
8699 if (complain & tf_error)
8708 arg = tsubst_default_argument (fn, parmnum, type, arg, complain);
8726 complain);
8727 arg = convert_for_arg_passing (type, arg, complain);
8756 convert_for_arg_passing (tree type, tree val, tsubst_flags_t complain)
8788 val = cp_perform_integral_promotions (val, complain);
8789 if (complain & tf_warning)
8806 if (complain & tf_warning)
8909 call_copy_ctor (tree a, tsubst_flags_t complain)
8913 tree copy = get_copy_ctor (ctype, complain);
8918 LOOKUP_NORMAL, NULL, complain);
9206 build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
9231 mark_used (fn, complain);
9241 callee = build_addr_func (fn, complain);
9266 exprimm = build_cplus_new (DECL_CONTEXT (fn), expr, complain);
9282 fold_non_dependent_expr (exprimm, complain,
9290 if (cand->warnings && (complain & tf_warning))
9294 joust (cand, w->loser, 1, complain);
9320 if (complain & tf_error)
9328 if (complain & tf_error)
9367 fn, complain))
9377 else if (!(complain & tf_error))
9386 tsubst_flags_t decltype_flag = (complain & tf_decltype);
9387 complain &= ~tf_decltype;
9389 tsubst_flags_t no_cleanup_complain = complain;
9390 complain &= ~tf_no_cleanup;
9438 gcc_assert (!(complain & tf_error));
9462 if (complain & tf_error)
9492 if (complain & tf_error)
9505 base_binfo = lookup_base (base_binfo, ctx, ba_unique, NULL, complain);
9533 base_binfo, 1, complain);
9587 tsubst_flags_t arg_complain = complain;
9609 complain);
9629 a = decay_conversion (a, complain);
9635 if (complain & tf_error)
9637 call_copy_ctor (a, complain);
9641 a = convert_arg_to_ellipsis (a, complain);
9656 if ((complain & tf_warning)
9688 if (complain & tf_error)
9770 if (!mark_used (fn, complain) && !(complain & tf_error))
9775 cp_handle_deprecated_or_unavailable (fn, complain);
9791 return force_target_expr (DECL_CONTEXT (fn), arg, complain);
9808 RO_ARROW, complain);
9838 arg0 = cp_build_addr_expr (to, complain);
9852 cp_handle_deprecated_or_unavailable (fn, complain);
9873 && !mark_used (fn, complain))
9887 ba_any, NULL, complain);
9891 complain);
9905 fn = build_addr_func (fn, complain);
9910 tree call = build_cxx_call (fn, nargs, argarray, complain|decltype_flag);
9938 call = build_cplus_new (DECL_CONTEXT (fndecl), call, complain);
9954 call = cxx_constant_value_sfinae (call, obj_arg, complain);
10398 tsubst_flags_t complain, tree orig_fndecl)
10457 if (!(complain & tf_decltype))
10459 fn = require_complete_type_sfinae (fn, complain);
10465 fn = build_cplus_new (TREE_TYPE (fn), fn, complain);
10498 /* We've built up a constructor call RET. Complain if it delegates to the
10526 tree binfo, int flags, tsubst_flags_t complain)
10550 if (!complete_type_or_maybe_complain (binfo, NULL_TREE, complain))
10582 binfo, /*nonnull=*/1, complain);
10616 if ((complain & tf_error)
10625 fns = lookup_fnfields (binfo, name, 1, complain);
10641 vtt = decay_conversion (vtt, complain);
10662 complain);
10667 if ((complain & tf_error)
10851 tree *fn_p, tsubst_flags_t complain)
10885 if (complain & tf_error)
10917 if (! (complain & tf_error))
10930 complain);
10945 *args = resolve_args (*args, complain);
11025 init = build_value_init (basetype, complain);
11031 init = reshape_init (basetype, init_list, complain);
11032 init = digest_init (basetype, init, complain);
11038 return get_target_expr_sfinae (init, complain);
11048 &candidates, complain);
11053 access_binfo, flags, &candidates, complain);
11085 ctor = digest_init (basetype, ctor, complain);
11093 if (complain & tf_error)
11103 cand = tourney (candidates, complain);
11110 if (complain & tf_error)
11139 && (complain & tf_warning))
11172 if (complain & tf_error)
11185 call = build_over_call (cand, flags, complain);
12031 tsubst_flags_t complain)
12132 if ((complain & tf_warning)
12184 if ((complain & tf_warning)
12199 /* We don't want to complain about `X::operator T1 ()'
12477 if (complain & tf_error)
12508 if (!pedantic && (complain & tf_warning_or_error))
12557 tourney (struct z_candidate *candidates, tsubst_flags_t complain)
12568 fate = joust (champ, challenger, 0, complain);
12598 fate = joust (champ, challenger, 0, complain);
12609 can_convert (tree to, tree from, tsubst_flags_t complain)
12616 return can_convert_arg (to, from, arg, LOOKUP_IMPLICIT, complain);
12623 can_convert_standard (tree to, tree from, tsubst_flags_t complain)
12625 return can_convert_arg (to, from, NULL_TREE, LOOKUP_IMPLICIT, complain);
12632 tsubst_flags_t complain)
12647 flags, complain);
12662 tsubst_flags_t complain)
12671 flags, complain);
12701 doing a bad conversion, convert_like will complain. */
12705 tsubst_flags_t complain, int flags)
12724 flags, complain);
12728 if (complain & tf_error)
12738 expr = convert_like (conv, expr, complain);
12748 perform_implicit_conversion (tree type, tree expr, tsubst_flags_t complain)
12750 return perform_implicit_conversion_flags (type, expr, complain,
12766 tsubst_flags_t complain)
12792 &args, type, LOOKUP_NORMAL, complain);
12793 return build_cplus_new (type, expr, complain);
12801 LOOKUP_NORMAL, complain);
12817 c_cast_p, complain);
13052 int flags, tsubst_flags_t complain)
13065 flags, complain);
13075 /*c_cast_p=*/false, flags, complain);
13082 if (complain & tf_error)
13085 convert_like (conv, expr, complain);
13102 expr = convert_like (conv, expr, complain);
Indexes created Mon Apr 27 00:23:16 UTC 2026