Lines Matching defs:complain
2338 tsubst_flags_t complain = tf_none;
2339 freq = tsubst_constraint_info (freq, fargs, complain, fn);
3030 /*complain*/true));
3821 expand_integer_pack (tree call, tree args, tsubst_flags_t complain,
3825 tree hi = tsubst_copy_and_build (ohi, args, complain, in_decl,
3835 tree ex = make_pack_expansion (call, complain);
3842 hi = instantiate_non_dependent_expr_sfinae (hi, complain);
3853 if ((complain & tf_error)
3873 expand_builtin_pack_call (tree call, tree args, tsubst_flags_t complain,
3882 return expand_integer_pack (call, args, complain, in_decl);
4177 make_pack_expansion (tree arg, tsubst_flags_t complain)
4223 if (complain & tf_error)
4289 if (complain & tf_error)
4352 containing context, but do complain about unexpanded capture packs. */
4517 /* Don't complain about the injected class name, as we've already
4585 tsubst_flags_t complain)
4620 (DECL_TEMPLATE_PARMS (orig_decl), args, complain);
4686 should be. Complain about "bare" parameter packs. */
5584 /* A lambda doesn't have an explicit declaration; don't complain
5646 /* Don't complain about an enclosing partial
6416 instantiate_non_dependent_expr_internal (tree expr, tsubst_flags_t complain)
6420 complain,
6429 instantiate_non_dependent_expr_sfinae (tree expr, tsubst_flags_t complain)
6439 expr = instantiate_non_dependent_expr_internal (expr, complain);
6730 tsubst_flags_t complain)
6763 if (complain & tf_error)
6781 if (complain & tf_error)
6816 tsubst_flags_t complain)
6832 if (complain & tf_error)
7115 invalid_tparm_referent_p (tree type, tree expr, tsubst_flags_t complain)
7121 complain);
7125 complain);
7130 if (invalid_tparm_referent_p (TREE_TYPE (e.value), e.value, complain))
7154 if (complain & tf_error)
7162 if (complain & tf_error)
7172 if (complain & tf_error)
7188 if (complain & tf_error)
7198 if (complain & tf_error)
7205 if (complain & tf_error)
7223 if (complain & tf_error)
7231 if (complain & tf_error)
7252 get_template_parm_object (tree expr, tsubst_flags_t complain)
7259 if ((complain & tf_error)
7264 if (invalid_tparm_referent_p (TREE_TYPE (expr), expr, complain))
7331 convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain)
7343 if (complain & tf_error)
7355 expr = decay_conversion (expr, complain);
7382 expr = instantiate_non_dependent_expr_internal (expr, complain);
7386 expr = canonicalize_expr_argument (expr, complain);
7412 expr = build_converted_constant_expr (type, expr, complain);
7416 return (complain & tf_error) ? NULL_TREE : error_mark_node;
7453 if (!mark_single_function (expr, complain))
7490 tree t = build_converted_constant_expr (type, expr, complain);
7503 if (complain & tf_error)
7549 we'll complain about it below. */
7586 else if (invalid_tparm_referent_p (type, expr, complain))
7610 if (complain & tf_error)
7618 if (complain & tf_error)
7636 if (complain & tf_error)
7651 if (invalid_tparm_referent_p (type, expr, complain))
7671 expr = decay_conversion (expr, complain);
7680 expr = convert_nontype_argument_function (type, expr, complain);
7694 if (complain & tf_error)
7704 expr = convert_nontype_argument_function (type, expr, complain);
7723 && !check_valid_ptrmem_cst_expr (type, expr, complain))
7740 && !check_valid_ptrmem_cst_expr (type, expr, complain))
7751 if (complain & tf_error)
7763 expr = get_template_parm_object (expr, complain);
7787 tsubst_flags_t complain,
7809 (parmparm, argparm, complain, in_decl, outer_args))
7831 tree t = tsubst (TREE_TYPE (parm), outer_args, complain, in_decl);
7856 tsubst_flags_t complain)
7898 complain,
7955 coerce_ttp_args_for_tta (tree& arg, tree pargs, tsubst_flags_t complain)
7965 pargs = coerce_template_args_for_ttp (arg_tmpl, pargs, complain);
7974 pargs = coerce_template_parms (aparms, pargs, arg_tmpl, complain,
8077 tsubst_flags_t complain,
8197 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
8220 if (!coerce_template_template_parm (parm, arg, complain, in_decl,
8313 canonicalize_type_argument (tree arg, tsubst_flags_t complain)
8320 && (complain & tf_warning))
8329 canonicalize_expr_argument (tree arg, tsubst_flags_t complain)
8336 && (complain & tf_warning))
8418 warning messages are issued under control of COMPLAIN. This
8426 tsubst_flags_t complain,
8474 else if (complain & tf_warning_or_error)
8503 if (complain & tf_error)
8515 complain);
8523 if (complain & tf_error)
8557 if (in_decl && (complain & tf_error))
8594 complain, in_decl,
8606 val = make_pack_expansion (val, complain);
8611 if (in_decl && (complain & tf_error))
8629 if (in_decl && (complain & tf_error))
8649 val = canonicalize_type_argument (val, complain);
8661 t = do_auto_deduction (t, arg, a, complain, adc_unify, args,
8667 t = tsubst (t, args, complain, in_decl);
8673 if (invalid_nontype_parm_type_p (t, complain))
8681 t = canonicalize_type_argument (t, complain);
8686 will report errors, which we don't want when complain
8695 val = convert_nontype_argument (t, orig_arg, complain);
8698 val = canonicalize_expr_argument (orig_arg, complain);
8705 else if (val == error_mark_node && (complain & tf_error))
8727 tree type = canonicalize_type_argument (TREE_TYPE (val), complain);
8729 complain);
8752 tsubst_flags_t complain)
8779 packed_parms = tsubst_pack_expansion (exp, args, complain, decl);
8797 && invalid_nontype_parm_type_p (TREE_TYPE (t), complain))
8844 if (complain & tf_error)
8849 arg, new_args, complain, parm_idx,
8859 if (complain & tf_error)
8902 warning messages are issued under control of COMPLAIN.
8915 tsubst_flags_t complain,
8983 if (complain & tf_error)
9010 if (complain & tf_error)
9066 && (arg || require_all_args || !(complain & tf_partial))
9074 in_decl, complain);
9119 complain, parm_idx,
9123 if (complain & tf_error)
9131 = make_pack_expansion (conv, complain);
9144 complain, in_decl);
9157 if (complain & tf_error)
9175 arg, new_args, complain,
9196 are empty, but wait until instantiation time to complain.
9218 if (complain & tf_error)
9237 gcc_assert (!(complain & tf_error) || seen_error ());
9267 tsubst_flags_t complain)
9269 return coerce_template_parms (parms, args, in_decl, complain, true, true);
9286 tsubst_flags_t complain,
9307 args, in_decl, complain,
9321 args, in_decl, complain,
9842 Issue error and warning messages under control of COMPLAIN.
9857 int entering_scope, tsubst_flags_t complain)
9919 if (complain & tf_error)
9927 || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (templ)
9930 if (complain & tf_error)
9939 complain &= ~tf_user;
9951 tree arglist2 = coerce_template_args_for_ttp (templ, arglist, complain);
9954 && check_instantiated_args (templ, arglist2, complain)))
10021 complain,
10067 if (complain & tf_error)
10083 complain))
10099 context = tsubst_aggr_type (context, arglist, complain, in_decl, true);
10103 context = tsubst (context, arglist, complain, in_decl);
10125 t = tsubst (TREE_TYPE (gen_tmpl), arglist, complain, in_decl);
10143 arglist, complain, in_decl),
10145 arglist, complain, in_decl),
10298 arglist, complain, NULL_TREE);
10321 /* We don't use COMPLAIN in the following call because this isn't
10403 int entering_scope, tsubst_flags_t complain)
10408 entering_scope, complain);
10429 finish_template_variable (tree var, tsubst_flags_t complain)
10435 arglist = coerce_innermost_template_parms (parms, arglist, templ, complain,
10443 if (complain & tf_error)
10452 return instantiate_template (templ, arglist, complain);
10460 tsubst_flags_t complain)
10470 complain &= ~tf_partial;
10471 templ = finish_template_variable (templ, complain);
11669 tsubst_flags_t complain, tree in_decl)
11682 complain, in_decl);
11699 = tsubst_expr (TREE_PURPOSE (val), args, complain,
11719 complain, in_decl);
11736 v = tsubst_expr (v, args, complain, in_decl, true);
11782 = tsubst_expr (TREE_CHAIN (val), args, complain, in_decl,
11791 tree pack = tsubst_pack_expansion (val, args, complain, in_decl);
11806 val = tsubst_expr (val, args, complain, in_decl,
11821 tsubst_flags_t complain, tree in_decl)
11839 tree subst = tsubst_attribute (t, NULL, args, complain, in_decl);
11857 ARGS, COMPLAIN, IN_DECL are as tsubst. Returns true normally,
11862 tree args, tsubst_flags_t complain, tree in_decl)
11907 *q = tsubst_attribute (t, decl_p, args, complain, in_decl);
12404 make_friend_class (type, friend_type, /*complain=*/false);
12424 add_friend (type, r, /*complain=*/false);
12505 tsubst_template_arg (tree t, tree args, tsubst_flags_t complain, tree in_decl)
12512 r = tsubst (t, args, complain, in_decl);
12515 if (!(complain & tf_warning))
12517 r = tsubst_expr (t, args, complain, in_decl,
12519 if (!(complain & tf_warning))
12707 COMPLAIN, and IN_DECL are the same parameters as for the
12722 tsubst_flags_t complain,
12748 if (!mark_used (parm, complain) && !(complain & tf_error))
12778 t = tsubst_decl (pattern, args, complain);
12782 t = tsubst_expr (pattern, args, complain, in_decl,
12786 t = tsubst (pattern, args, complain, in_decl);
12797 t = make_pack_expansion (t, complain);
12811 expand_empty_fold (tree t, tsubst_flags_t complain)
12827 if (complain & tf_error)
12838 fold_expression (tree t, tree left, tree right, tsubst_flags_t complain)
12847 lookups, complain);
12854 lookups, complain);
12860 complain);
12867 tsubst_fold_expr_pack (tree t, tree args, tsubst_flags_t complain, tree in_decl)
12869 return tsubst_pack_expansion (FOLD_EXPR_PACK (t), args, complain, in_decl);
12875 tsubst_fold_expr_init (tree t, tree args, tsubst_flags_t complain, tree in_decl)
12877 return tsubst_expr (FOLD_EXPR_INIT (t), args, complain, in_decl, false);
12891 expand_left_fold (tree t, tree pack, tsubst_flags_t complain)
12897 left = fold_expression (t, left, right, complain);
12905 tsubst_unary_left_fold (tree t, tree args, tsubst_flags_t complain,
12908 tree pack = tsubst_fold_expr_pack (t, args, complain, in_decl);
12918 return expand_empty_fold (t, complain);
12920 return expand_left_fold (t, pack, complain);
12929 tsubst_binary_left_fold (tree t, tree args, tsubst_flags_t complain,
12932 tree pack = tsubst_fold_expr_pack (t, args, complain, in_decl);
12935 tree init = tsubst_fold_expr_init (t, args, complain, in_decl);
12952 return expand_left_fold (t, vec, complain);
12966 expand_right_fold (tree t, tree pack, tsubst_flags_t complain)
12974 right = fold_expression (t, left, right, complain);
12982 tsubst_unary_right_fold (tree t, tree args, tsubst_flags_t complain,
12985 tree pack = tsubst_fold_expr_pack (t, args, complain, in_decl);
12995 return expand_empty_fold (t, complain);
12997 return expand_right_fold (t, pack, complain);
13006 tsubst_binary_right_fold (tree t, tree args, tsubst_flags_t complain,
13009 tree pack = tsubst_fold_expr_pack (t, args, complain, in_decl);
13012 tree init = tsubst_fold_expr_init (t, args, complain, in_decl);
13030 return expand_right_fold (t, vec, complain);
13045 tsubst_flags_t complain;
13052 : extra (NULL_TREE), complain (c) {}
13059 tsubst_flags_t complain = data.complain;
13143 carg = process_outer_var_ref (arg, complain);
13161 spec = process_outer_var_ref (spec, complain);
13167 extract_local_specs (tree pattern, tsubst_flags_t complain)
13169 el_data data (complain);
13191 build_extra_args (tree pattern, tree args, tsubst_flags_t complain)
13197 if (tree locals = extract_local_specs (pattern, complain))
13206 add_extra_args (tree extra, tree args, tsubst_flags_t complain, tree in_decl)
13230 extra = tsubst_template_args (extra, args, complain, in_decl);
13244 tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain,
13259 args = add_extra_args (PACK_EXPANSION_EXTRA_ARGS (t), args, complain, in_decl);
13280 args, complain,
13282 complain);
13285 args, complain, in_decl,
13286 false), complain);
13292 if (complain & tf_error)
13298 complain, in_decl);
13320 arg_pack = tsubst_decl (parm_pack, args, complain);
13378 if (!(complain & tf_error))
13440 t = make_pack_expansion (pattern, complain);
13442 = build_extra_args (pattern, args, complain);
13460 result = tsubst_expr (pattern, args, complain, in_decl,
13463 result = tsubst (pattern, args, complain, in_decl);
13464 result = make_pack_expansion (result, complain);
13491 elem_args, complain,
13585 tsubst_argument_pack (tree orig_arg, tree args, tsubst_flags_t complain,
13590 args, complain, in_decl);
13614 tsubst_template_args (tree t, tree args, tsubst_flags_t complain, tree in_decl)
13634 new_arg = tsubst_template_args (orig_arg, args, complain, in_decl);
13638 new_arg = tsubst_pack_expansion (orig_arg, args, complain, in_decl);
13650 new_arg = tsubst_argument_pack (orig_arg, args, complain, in_decl);
13652 new_arg = tsubst_template_arg (orig_arg, args, complain, in_decl);
13707 tsubst_template_parms_level (tree parms, tree args, tsubst_flags_t complain)
13722 tsubst_template_parm (tuple, args, complain);
13736 tsubst_template_parms (tree parms, tree args, tsubst_flags_t complain)
13753 args, complain);
13773 tsubst_template_parm (tree t, tree args, tsubst_flags_t complain)
13787 parm_decl = tsubst (parm_decl, args, complain, NULL_TREE);
13789 && invalid_nontype_parm_type_p (TREE_TYPE (parm_decl), complain))
13792 complain, NULL_TREE);
13804 tsubst_flags_t complain)
13815 complain, NULL_TREE);
13830 tsubst_flags_t complain,
13843 return tsubst (t, args, complain, in_decl);
13849 return tsubst (TYPE_PTRMEMFUNC_FN_TYPE (t), args, complain, in_decl);
13868 context = tsubst_aggr_type (context, args, complain,
13885 complain, in_decl);
13888 else if (!entering_scope && (complain & tf_dguide)
13903 entering_scope, complain);
13904 r = cp_build_qualified_type_real (r, cp_type_quals (t), complain);
13914 return tsubst (t, args, complain, in_decl);
13946 tsubst_flags_t complain)
14004 complain, NULL_TREE,
14011 arg = check_default_argument (type, arg, complain);
14014 && (complain & tf_warning_or_error))
14031 tsubst_default_arguments (tree fn, tsubst_flags_t complain)
14054 complain);
14086 tree raises, tsubst_flags_t complain)
14100 r = cp_build_qualified_type_real (r, type_memfn_quals (t), complain);
14110 if (complain & tf_error)
14192 tsubst_function_decl (tree t, tree args, tsubst_flags_t complain,
14237 args, complain, in_decl);
14276 complain, t, /*entering_scope=*/1);
14280 complain | tf_fndecl_type, in_decl));
14309 spec = tsubst_copy_and_build (spec, args, complain, in_decl,
14312 spec = build_explicit_specifier (spec, complain);
14330 argtype = tsubst (argtype, args, complain, in_decl);
14348 parms = tsubst (parms, args, complain, t);
14381 the specialization so that we'll complain eventually. */
14382 if ((complain & tf_error) == 0
14384 && !grok_op_properties (r, /*complain=*/false))
14396 args, complain, in_decl));
14399 args, complain, in_decl))
14432 tsubst_default_arguments (r, complain);
14449 = tsubst (TREE_VALUE (*friends), args, complain, in_decl);
14463 else if ((complain & tf_error) != 0
14465 && !grok_op_properties (r, /*complain=*/true))
14493 tsubst_template_decl (tree t, tree args, tsubst_flags_t complain,
14509 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14538 complain, in_decl);
14585 complain);
14591 inner = tsubst_function_decl (inner, args, complain, lambda_fntype);
14600 inner = tsubst_aggr_type (inner, args, complain,
14603 inner = tsubst (inner, args, complain, in_decl);
14735 control of COMPLAIN. */
14738 tsubst_decl (tree t, tree args, tsubst_flags_t complain)
14753 r = tsubst_template_decl (t, args, complain, /*lambda*/NULL_TREE);
14757 r = tsubst_function_decl (t, args, complain, /*lambda*/NULL_TREE);
14784 complain, in_decl);
14792 RETURN (tsubst (TREE_CHAIN (t), args, complain,
14827 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14839 complain, in_decl);
14848 args, complain, in_decl))
14867 complain, DECL_CHAIN (t));
14886 complain, in_decl);
14910 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
14922 complain, in_decl,
14939 args, complain, in_decl))
14960 tree name = tsubst_copy (DECL_NAME (t), args, complain, in_decl);
14963 tree vec = tsubst_pack_expansion (scope, args, complain, in_decl);
14986 complain, in_decl);
15023 type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15042 complain,
15064 argvec = tsubst (DECL_TI_ARGS (t), args, complain
15068 argvec, tmpl, complain,
15112 tsubst_flags_t tcomplain = complain;
15167 ve = tsubst_expr (ve, args, complain, in_decl,
15236 if (!error_operand_p (r) || (complain & tf_error))
15251 args, complain, in_decl))
15288 tsubst_flags_t complain,
15291 return tsubst_arg_types (parms, args, NULL_TREE, complain, in_decl);
15302 tsubst_flags_t complain,
15318 args, complain, in_decl);
15332 type = tsubst (TREE_VALUE (arg_types), args, complain, in_decl);
15345 if (complain & tf_error)
15366 default_arg = tsubst_copy_and_build (default_arg, args, complain, in_decl,
15370 args, end, complain, in_decl);
15422 tsubst_flags_t complain,
15439 complain, in_decl);
15455 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15465 return_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
15474 if (complain & tf_error)
15488 complain, in_decl);
15495 /*raises=*/NULL_TREE, complain);
15505 tsubst_flags_t complain,
15549 (expr, args, complain, in_decl, /*function_p=*/false,
15552 new_specs = build_noexcept_spec (new_specs, complain);
15585 args, complain,
15601 complain);
15612 spec = tsubst (TREE_VALUE (specs), args, complain, in_decl);
15616 complain);
15629 tsubst_tree_list (tree t, tree args, tsubst_flags_t complain, tree in_decl)
15640 purpose = tsubst_pack_expansion (purpose, args, complain, in_decl);
15645 purpose = tsubst (purpose, args, complain, in_decl);
15647 purpose = tsubst_copy_and_build (purpose, args, complain, in_decl);
15657 value = tsubst_pack_expansion (value, args, complain, in_decl);
15662 value = tsubst (value, args, complain, in_decl);
15664 value = tsubst_copy_and_build (value, args, complain, in_decl);
15672 chain = tsubst_tree_list (chain, args, complain, in_decl);
15674 chain = tsubst (chain, args, complain, in_decl);
15676 chain = tsubst_copy_and_build (chain, args, complain, in_decl);
15716 Issue error and warning messages under control of COMPLAIN. Note
15730 tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
15745 return tsubst_decl (t, args, complain);
15769 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
15770 r = instantiate_alias_template (tmpl, gen_args, complain);
15777 tree gen_args = tsubst (DECL_TI_ARGS (decl), args, complain, in_decl);
15793 complain | tf_ignore_bad_quals);
15802 complain | tf_ignore_bad_quals);
15806 bool fndecl_type = (complain & tf_fndecl_type);
15807 complain &= ~tf_fndecl_type;
15809 bool tst_ok = (complain & tf_tst_ok);
15810 complain &= ~tf_tst_ok;
15819 type = tsubst (type, args, complain, in_decl);
15828 return tsubst_aggr_type (t, args, complain, in_decl,
15854 max = tsubst_expr (omax, args, complain, in_decl,
15874 return compute_array_index_type (NULL_TREE, max, complain);
15881 tmpl = tsubst_copy (tmpl, args, complain, in_decl);
15950 (arg, quals, complain | tf_ignore_bad_quals);
15957 args, complain, in_decl);
15999 complain);
16013 complain);
16015 (r, cp_type_quals (t) | cp_type_quals (r), complain);
16035 if (complain & tf_partial)
16048 r = tsubst (TYPE_MAIN_VARIANT (t), args, complain, in_decl);
16051 complain | (code == TEMPLATE_TYPE_PARM
16075 r, levels, args, complain);
16107 complain, in_decl);
16111 complain, in_decl);
16125 type = tsubst (type, args, complain, in_decl);
16128 r = reduce_template_parm_level (t, type, levels, args, complain);
16139 return tsubst_tree_list (t, args, complain, in_decl);
16148 return tsubst_template_args (t, args, complain, in_decl);
16177 if (complain & tf_error
16195 if (complain & tf_error)
16228 r = cp_build_qualified_type_real (r, cp_type_quals (t), complain);
16238 r = tsubst (TYPE_OFFSET_BASETYPE (t), args, complain, in_decl);
16248 if (complain & tf_error)
16254 if (complain & tf_error)
16260 if (complain & tf_error)
16275 complain);
16280 complain);
16287 fntype = tsubst_function_type (t, args, complain, in_decl);
16292 specs = tsubst_exception_specification (t, args, complain, in_decl,
16302 tree domain = tsubst (TYPE_DOMAIN (t), args, complain, in_decl);
16326 if (complain & tf_error)
16332 !(complain & tf_error)))
16338 (complain & tf_error)))
16355 ctx = tsubst_pack_expansion (ctx, args, complain, in_decl);
16361 if (complain & tf_error)
16369 ctx = tsubst_aggr_type (ctx, args, complain, in_decl,
16375 complain, in_decl);
16381 if (complain & tf_error)
16395 if (!complete_type_or_maybe_complain (ctx, NULL_TREE, complain))
16399 tsubst_flags_t tcomplain = complain | tf_keep_type_decl;
16407 complain |= tf_ignore_bad_quals;
16415 if (complain & tf_error)
16423 if (complain & tf_error)
16432 (f, cp_type_quals (f) | cp_type_quals (t), complain);
16437 tree ctx = tsubst_aggr_type (TYPE_CONTEXT (t), args, complain,
16446 parm_list = tsubst_template_parms (parm_list, args, complain);
16447 return make_unbound_class_template (ctx, name, parm_list, complain);
16458 complain, in_decl,
16468 complain);
16479 complain|tf_decltype, in_decl,
16502 type = finish_decltype_type (type, id, complain);
16507 complain | tf_ignore_bad_quals);
16513 complain, in_decl);
16519 return tsubst_argument_pack (t, args, complain, in_decl);
16629 tree args, tsubst_flags_t complain, tree in_decl)
16633 qualifying_scope = tsubst (qualifying_scope, args, complain, in_decl);
16636 optype = tsubst (optype, args, complain, in_decl);
16648 complain, in_decl);
16652 binfo_type = tsubst (binfo_type, args, complain, in_decl);
16663 if ((complain & tf_dguide) && dependent_scope_p (qualifying_scope))
16678 complain);
16694 if ((complain & tf_error)
16714 ba_unique, nullptr, complain);
16724 bool ok = mark_used (fn, complain);
16725 if (!ok && !(complain & tf_error))
16769 tsubst_flags_t complain, tree in_decl,
16789 complain, in_decl);
16807 scope = tsubst (scope, args, complain, in_decl);
16808 expr = tsubst_copy (name, args, complain, in_decl);
16851 if (complain & tf_error)
16864 scope, complain))
16867 if (!mark_used (expr, complain) && !(complain & tf_error))
16873 if (complain & tf_error)
16893 complain);
16898 if (expr == error_mark_node && complain & tf_error)
16908 /*template_arg_p=*/false, complain));
16932 tsubst_flags_t complain, tree in_decl)
16937 init = tsubst_expr (init, args, complain, in_decl, false);
16947 if (complain & tf_error)
16962 init = build_value_init (type, complain);
16964 init = get_target_expr_sfinae (init, complain);
16980 maybe_dependent_member_ref (tree t, tree args, tsubst_flags_t complain,
16983 if (!(complain & tf_dguide))
16990 ctx = tsubst (ctx, args, complain, in_decl);
17003 tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
17028 r = tsubst_decl (t, args, complain);
17037 if (!mark_used (r, complain) && !(complain & tf_error))
17047 return tsubst_copy (DECL_INITIAL (t), args, complain, in_decl);
17051 if (tree ref = maybe_dependent_member_ref (t, args, complain, in_decl))
17065 = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
17086 ctx = tsubst_aggr_type (DECL_CONTEXT (t), args, complain, in_decl,
17093 if (complain & tf_error)
17104 if (tree ref = maybe_dependent_member_ref (t, args, complain, in_decl))
17109 r = tsubst (t, args, complain, in_decl);
17158 r = tsubst_decl (t, args, complain);
17167 complain, in_decl);
17179 complain, adc_variable_type);
17186 r = process_outer_var_ref (r, complain);
17197 if (!mark_used (r, complain))
17209 args, complain, in_decl);
17214 args, complain, in_decl);
17216 return tsubst (t, args, complain, in_decl);
17235 tree context = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
17236 if ((complain & tf_dguide) && dependent_scope_p (context))
17243 NULL_TREE, complain);
17244 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
17264 complain, in_decl);
17272 op = tsubst_copy (op, args, complain, in_decl);
17278 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
17298 op = tsubst_copy (op, args, complain, in_decl);
17316 tsubst_flags_t tcomplain = complain;
17320 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17326 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
17327 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17347 expanded = tsubst_pack_expansion (op, args, complain, in_decl);
17350 args, complain, in_decl);
17381 complain & tf_error);
17386 complain & tf_error);
17394 args, complain, in_decl);
17397 tsubst (TREE_TYPE (t), args, complain, in_decl), r);
17418 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
17419 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17438 object = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17443 complain, in_decl);
17450 complain, in_decl);
17453 complain, in_decl);
17462 args, complain,
17465 name = tsubst_copy (name, args, complain, in_decl);
17504 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17505 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
17511 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17512 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
17519 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17520 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
17531 complain, in_decl);
17540 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17541 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
17542 tree op2 = tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl);
17550 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17551 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
17552 tree op2 = tsubst_copy (TREE_OPERAND (t, 2), args, complain, in_decl);
17560 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17561 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
17574 tmpl = tsubst_copy (tmpl, args, complain, in_decl);
17576 targs = tsubst_template_args (targs, args, complain, in_decl);
17593 purpose = tsubst_copy (purpose, args, complain, in_decl);
17596 value = tsubst_copy (value, args, complain, in_decl);
17599 chain = tsubst_copy (chain, args, complain, in_decl);
17626 return tsubst (t, args, complain, in_decl);
17634 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
17646 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17647 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
17659 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
17660 tree op0 = tsubst_copy (TREE_OPERAND (t, 0), args, complain, in_decl);
17661 tree op1 = tsubst_copy (TREE_OPERAND (t, 1), args, complain, in_decl);
17664 if (!mark_used (TREE_OPERAND (r, 1), complain)
17665 && !(complain & tf_error))
17688 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
17696 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
17713 return tsubst_unary_left_fold (t, args, complain, in_decl);
17715 return tsubst_unary_right_fold (t, args, complain, in_decl);
17717 return tsubst_binary_left_fold (t, args, complain, in_decl);
17719 return tsubst_binary_right_fold (t, args, complain, in_decl);
17730 complain, in_decl,
17746 tsubst_omp_clause_decl (tree decl, tree args, tsubst_flags_t complain,
17768 = tsubst_decl (TREE_VEC_ELT (it, 0), args, complain);
17772 = tsubst_expr (TREE_VEC_ELT (it, 1), args, complain, in_decl,
17775 = tsubst_expr (TREE_VEC_ELT (it, 2), args, complain, in_decl,
17778 = tsubst_expr (TREE_VEC_ELT (it, 3), args, complain, in_decl,
17788 args, complain,
17801 = tsubst_expr (TREE_PURPOSE (decl), args, complain, in_decl,
17803 tree length = tsubst_expr (TREE_VALUE (decl), args, complain, in_decl,
17805 tree chain = tsubst_omp_clause_decl (TREE_CHAIN (decl), args, complain,
17816 tree ret = tsubst_expr (decl, args, complain, in_decl,
17830 tree args, tsubst_flags_t complain, tree in_decl)
17848 tsubst_expr (OMP_CLAUSE_LASTPRIVATE_STMT (oc), args, complain,
17873 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
17880 complain, in_decl,
17909 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 0), args, complain,
17921 complain, in_decl);
17931 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
17937 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
17940 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 1), args, complain,
17945 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
17948 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 1), args, complain,
17951 = tsubst_expr (OMP_CLAUSE_OPERAND (oc, 2), args, complain,
17956 = tsubst_omp_clause_decl (OMP_CLAUSE_DECL (oc), args, complain,
17966 complain, in_decl, NULL);
17969 = tsubst_expr (OMP_CLAUSE_LINEAR_STEP (oc), args, complain,
18084 tsubst_copy_asm_operands (tree t, tree args, tsubst_flags_t complain,
18087 #define RECUR(t) tsubst_copy_asm_operands (t, args, complain, in_decl)
18095 return tsubst_copy_and_build (t, args, complain, in_decl,
18138 tree args, tsubst_flags_t complain, tree in_decl,
18142 tsubst_expr ((NODE), args, complain, in_decl, \
18166 tree d = tsubst_decl (TREE_OPERAND (v, 0), args, complain);
18168 d = tsubst_decomp_names (d, TREE_OPERAND (v, 0), args, complain,
18189 decl = tsubst_decl (decl, args, complain);
18200 decl = tsubst_decl (decl, args, complain);
18242 = tsubst_decl (TREE_VEC_ELT (init, 0), args, complain);
18282 = do_auto_deduction (TREE_TYPE (decl), init, auto_node, complain);
18306 = tsubst_decl (TREE_VEC_ELT (rhs, 0), args, complain);
18320 NOP_EXPR, rhs, NULL_TREE, complain);
18503 tsubst_flags_t complain, tree in_decl, tree *first,
18527 decl3 = tsubst (decl2, args, complain, in_decl);
18608 tsubst_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl,
18613 tsubst_expr ((NODE), args, complain, in_decl, \
18686 scope = tsubst (scope, args, complain, in_decl);
18690 if (complain & tf_error)
18704 complain, in_decl));
18748 decl = tsubst (decl, args, complain, in_decl);
18803 complain, in_decl, &first,
18806 init = tsubst_init (init, decl, args, complain, in_decl);
18869 decl = tsubst (decl, args, complain, in_decl);
18877 complain, in_decl,
18933 args = add_extra_args (IF_STMT_EXTRA_ARGS (t), args, complain, in_decl);
18947 IF_STMT_EXTRA_ARGS (stmt) = build_extra_args (stmt, args, complain);
18962 tree folded = fold_non_dependent_expr (tmp, complain);
18976 tree folded = fold_non_dependent_expr (tmp, complain);
19066 complain, in_decl);
19068 complain, in_decl);
19070 complain, in_decl);
19072 complain, in_decl);
19121 decl = tsubst (decl, args, complain, in_decl);
19136 tmp = tsubst (TREE_TYPE (t), args, complain, NULL_TREE);
19173 complain, in_decl,
19187 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), C_ORT_ACC, args, complain,
19197 complain, in_decl);
19212 complain, in_decl);
19220 complain, in_decl);
19246 clauses = tsubst_omp_clauses (OMP_FOR_CLAUSES (t), ort, args, complain,
19270 complain, in_decl,
19326 tmp = tsubst_omp_clauses (OMP_CLAUSES (t), C_ORT_OMP, args, complain,
19366 args, complain, in_decl);
19392 args, complain, in_decl);
19444 complain, in_decl);
19453 complain, in_decl);
19464 complain, in_decl);
19472 complain, in_decl);
19501 complain, in_decl);
19649 complain));
19657 RETURN (tsubst_copy_and_build (t, args, complain, in_decl,
19675 tsubst_omp_udr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
19697 args, complain, in_decl);
19699 args, complain, in_decl);
19706 tsubst_expr (stmts[2], args, complain, in_decl, false);
19719 args, complain, in_decl);
19721 args, complain, in_decl);
19726 tsubst_expr (stmts[5], args, complain, in_decl, false);
19743 tsubst_flags_t complain,
19747 t = tsubst_qualified_id (t, args, complain, in_decl,
19750 t = tsubst_copy_and_build (t, args, complain, in_decl,
19764 tsubst_flags_t complain)
19771 if (complain & tf_error)
19776 init = build_x_compound_expr_from_list (init, ELK_INIT, complain);
19778 type = do_auto_deduction (TREE_TYPE (field), init, auto_node, complain);
19792 tsubst_lambda_expr (tree t, tree args, tsubst_flags_t complain, tree in_decl)
19823 init = tsubst_pack_expansion (init, args, complain, in_decl);
19825 init = tsubst_copy_and_build (init, args, complain, in_decl,
19832 init = build_x_compound_expr_from_list (init, ELK_INIT, complain);
19853 tree field = tsubst_decl (ofield, args, complain);
19875 complain);
19880 LAMBDA_CAPTURE_EXPLICIT_P (cap), complain);
19919 fntype = tsubst (fntype, args, complain, in_decl);
19939 tmpl = tsubst_template_decl (oldtmpl, args, complain, fntype);
19951 fn = tsubst_function_decl (oldfn, args, complain, fntype);
20004 complain = tf_warning_or_error;
20012 tsubst_expr (saved, args, complain, r, /*constexpr*/false);
20043 fold_targs_r (tree targs, tsubst_flags_t complain)
20054 if (!fold_targs_r (ARGUMENT_PACK_ARGS (elt), complain))
20062 elt = cxx_constant_value_sfinae (elt, NULL_TREE, complain);
20076 maybe_fold_fn_template_args (tree fn, tsubst_flags_t complain)
20094 return fold_targs_r (targs, complain);
20101 tsubst_copy_and_build_call_args (tree t, tree args, tsubst_flags_t complain,
20113 tsubst_copy_and_build (arg, args, complain, in_decl,
20119 arg = tsubst_pack_expansion (arg, args, complain, in_decl);
20147 tsubst_flags_t complain,
20154 tsubst_copy_and_build (NODE, args, complain, in_decl, \
20170 tsubst_flags_t decltype_flag = (complain & tf_decltype);
20171 complain &= ~tf_decltype;
20187 tree new_type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20214 if (complain & tf_error)
20225 complain, in_decl,
20231 targs = tsubst_template_args (targs, args, complain, in_decl);
20245 tree check = build_concept_check (templ, targs, complain);
20262 complain);
20305 complain|decltype_flag);
20315 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20322 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20340 RETURN (perform_implicit_conversion_flags (type, expr, complain,
20346 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20362 tsubst_flags_t tcomplain = complain;
20369 if (complain & tf_error)
20383 r = build_functional_cast (input_location, type, op, complain);
20386 r = build_reinterpret_cast (input_location, type, op, complain);
20389 r = build_const_cast (input_location, type, op, complain);
20392 r = build_dynamic_cast (input_location, type, op, complain);
20395 r = build_static_cast (input_location, type, op, complain);
20408 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
20410 RETURN (cp_build_bit_cast (EXPR_LOCATION (t), type, op0, complain));
20416 args, complain, in_decl);
20419 complain|decltype_flag));
20433 complain|decltype_flag));
20445 op1 = tsubst_qualified_id (op1, args, complain, in_decl,
20448 op1 = tsubst_non_call_postfix_expression (op1, args, complain,
20452 complain|decltype_flag));
20519 complain|decltype_flag);
20538 RETURN (tsubst_qualified_id (t, args, complain, in_decl, /*done=*/true,
20543 args, complain, in_decl));
20547 args, complain, in_decl);
20554 tsubst_copy_and_build_call_args (c, args, complain, in_decl,
20563 complain | decltype_flag);
20567 complain | decltype_flag);
20572 complain|decltype_flag));
20577 RETURN (tsubst_copy (t, args, complain, in_decl));
20602 op1 = tsubst (op1, args, complain, in_decl);
20604 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
20614 complain & tf_error);
20618 complain & tf_error);
20644 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
20657 op1 = tsubst_copy_and_build (op1, args, complain, in_decl,
20663 RETURN (finish_noexcept_expr (op1, complain));
20674 complain|decltype_flag);
20689 args, complain, in_decl);
20692 && !mark_used (op1, complain) && !(complain & tf_error))
20694 RETURN (build_x_arrow (input_location, op1, complain));
20741 tree op1 = tsubst (TREE_OPERAND (t, 1), args, complain, in_decl);
20745 complain);
20762 complain));
20768 complain & ~tf_decltype, in_decl,
20775 complain|decltype_flag));
20802 function = tsubst_qualified_id (function, args, complain, in_decl,
20827 function = tsubst_copy (function, args, complain, in_decl);
20847 tsubst_flags_t subcomplain = complain;
20864 tsubst_copy_and_build_call_args (t, args, complain, in_decl,
20887 function = resolve_nondeduced_context (function, complain);
20953 if (koenig_p && (complain & tf_warning_or_error))
20959 (function, args, complain, in_decl, true,
21025 if (complain & tf_error)
21045 && !mark_used (inner, complain) && !(complain & tf_error))
21049 if (!maybe_fold_fn_template_args (function, complain))
21053 complain |= decltype_flag;
21069 (*call_args)[0], complain);
21084 complain, in_decl),
21085 complain);
21093 complain);
21107 complain);
21124 complain);
21131 complain));
21151 complain);
21174 tree folded_cond = fold_non_dependent_expr (cond, complain);
21203 cond, exp1, exp2, complain));
21210 tree op2 = tsubst (TREE_OPERAND (t, 2), args, complain, in_decl);
21216 RETURN (tsubst_tree_list (t, args, complain, in_decl));
21226 args, complain, in_decl);
21229 && !mark_used (object, complain) && !(complain & tf_error))
21237 args, complain, in_decl);
21239 member = tsubst_copy (member, args, complain, in_decl);
21288 /*complain=*/false);
21309 if (complain & tf_error)
21323 complain);
21343 tsubst_flags_t tcomplain = complain;
21374 ce->value = tsubst_pack_expansion (ce->value, args, complain,
21425 RETURN (finish_compound_literal (type, r, complain, cl));
21437 operand_0 = tsubst (operand_0, args, complain, in_decl);
21438 RETURN (get_typeid (operand_0, complain));
21443 RETURN (build_typeid (operand_0, complain));
21454 tree r = tsubst_copy (t, args, complain, in_decl);
21461 r = process_outer_var_ref (r, complain);
21473 tree type = tsubst (TREE_TYPE (t), args, complain, in_decl);
21480 = tsubst_copy_and_build (TREE_OPERAND (t, 1), args, complain,
21490 RECUR (TREE_OPERAND (t, 0)), complain));
21495 complain, in_decl);
21497 complain, in_decl);
21508 tsubst_expr (STMT_EXPR_STMT (t), args, complain, in_decl,
21523 if (complain & tf_partial)
21530 tree r = tsubst_lambda_expr (t, args, complain, in_decl);
21536 RETURN (tsubst_expr(t, args, complain, in_decl,
21556 complain));
21590 = objcp_tsubst_copy_and_build (t, args, complain,
21595 RETURN (tsubst_copy (t, args, complain, in_decl));
21608 Emit an error under control of COMPLAIN, and return TRUE on error. */
21611 check_instantiated_arg (tree tmpl, tree t, tsubst_flags_t complain)
21623 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (vec, i), complain))
21643 if (complain & tf_error)
21657 if (complain & tf_error)
21672 if (complain & tf_error)
21680 check_instantiated_args (tree tmpl, tree args, tsubst_flags_t complain)
21687 if (check_instantiated_arg (tmpl, TREE_VEC_ELT (args, ix), complain))
21690 if (result && (complain & tf_error))
21718 instantiate_template_1 (tree tmpl, tree orig_args, tsubst_flags_t complain)
21743 targ_ptr, complain);
21784 if (complain & tf_error)
21792 complain))
21812 complain, gen_tmpl, true);
21825 tree elt = most_specialized_partial_spec (tid, complain);
21833 fndecl = tsubst (partial_pat, partial_args, complain, gen_tmpl);
21839 fndecl = tsubst (pattern, targ_ptr, complain, gen_tmpl);
21864 if (!perform_deferred_access_checks (complain))
21880 if (!(complain & tf_error))
21894 instantiate_template (tree tmpl, tree orig_args, tsubst_flags_t complain)
21898 ret = instantiate_template_1 (tmpl, orig_args, complain);
21909 instantiate_alias_template (tree tmpl, tree args, tsubst_flags_t complain)
21915 if (complain & tf_dguide)
21917 tree ctx = tsubst_aggr_type (DECL_CONTEXT (tmpl), args, complain,
21931 args, tmpl, complain,
21940 if (complain & tf_error)
21951 tree r = instantiate_template (tmpl, args, complain);
22103 tsubst_flags_t complain
22127 complain |= tf_decltype;
22182 complain|tf_partial,
22243 tsubst_flags_t ecomplain = complain | tf_partial | tf_fndecl_type;
22379 decl = instantiate_template (fn, targs, complain);
22391 ok = perform_access_checks (checks, complain);
22432 decl = instantiate_template (orig_fn, targs, complain);
22604 tsubst_flags_t complain = (explain_p ? tf_warning_or_error : tf_none);
22607 if (can_convert_arg (type, parm, NULL_TREE, flags, complain))
22617 = good_conversion (parm, type, conv_arg, flags, complain));
22619 ok = can_convert_arg (parm, type, conv_arg, flags, complain);
23040 tsubst_flags_t complain = (explain_p
23155 tree type = tsubst (TREE_TYPE (parm), full_targs, complain,
23178 substed = tsubst_template_arg (arg, full_targs, complain,
23188 substed = tsubst_template_arg (arg, full_targs, complain,
23193 complain, i, NULL_TREE);
23380 resolve_nondeduced_context (tree orig_expr, tsubst_flags_t complain)
23464 expr = build_offset_ref (base, expr, addr, complain);
23467 expr = cp_build_addr_expr (expr, complain);
23470 else if (good == 0 && badargs && (complain & tf_error))
23473 instantiate_template (badfn, badargs, complain);
23481 resolve_nondeduced_context_or_error (tree exp, tsubst_flags_t complain)
23483 exp = resolve_nondeduced_context (exp, complain);
23486 if (complain & tf_error)
23538 some template args from previous args, unify would complain when we
24159 tsubst_flags_t complain = (explain_p
24496 complain, adc_unify, targs,
24891 parm = fold_non_dependent_expr (parm, complain);
24927 arg = make_pack_expansion (arg, complain);
25741 most_specialized_partial_spec (tree target, tsubst_flags_t complain)
25869 if (!(complain & tf_error))
25982 We check DECL_NOT_REALLY_EXTERN so as not to complain when
26038 non-null, is the RID for extern, inline or static. COMPLAIN is
26043 do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
26059 if (complain & tf_error)
26119 if (!extern_p && (complain & tf_error))
26350 maybe_instantiate_noexcept (tree fn, tsubst_flags_t complain)
26397 if (!maybe_instantiate_noexcept (prime, complain))
26407 spec = get_defaulted_eh_spec (fn, complain);
27298 inform messages under control of COMPLAIN. */
27301 invalid_nontype_parm_type_p (tree type, tsubst_flags_t complain)
27316 if (complain & tf_error)
27340 if (!complete_type_or_maybe_complain (type, NULL_TREE, complain))
27344 if (complain & tf_error)
27355 if (complain & tf_error)
27361 if (complain & tf_error)
29326 LEVEL:INDEX, using tsubst_args and complain for substitution into non-type
29333 tree tsubst_args, tsubst_flags_t complain)
29355 complain|tf_partial, NULL_TREE);
29358 complain, NULL_TREE);
29362 complain, NULL_TREE);
29405 complain|tf_partial);
29410 complain);
29451 tree targs, unsigned targs_index, tsubst_flags_t complain)
29455 targs, complain);
29459 targs, complain, NULL_TREE);
29463 targs, complain, NULL_TREE);
29476 build_deduction_guide (tree type, tree ctor, tree outer_args, tsubst_flags_t complain)
29487 type = tsubst (type, outer_args, complain, CLASSTYPE_TI_TEMPLATE (type));
29519 complain |= tf_dguide;
29525 fn_tmpl = tsubst (fn_tmpl, outer_args, complain, ctor);
29587 tsubst_args, i, complain);
29597 complain, ctor);
29607 ci = tsubst_constraint_info (ci, outer_args, complain, ctor);
29608 ci = tsubst_constraint_info (ci, tsubst_args, complain, ctor);
29614 fargs = tsubst (fargs, tsubst_args, complain, ctor);
29622 fparms = tsubst_arg_types (fparms, targs, NULL_TREE, complain, ctor);
29623 fargs = tsubst (fargs, targs, complain, ctor);
29628 ci = tsubst_constraint_info (ci, outer_args, complain, ctor);
29629 ci = tsubst_constraint_info (ci, targs, complain, ctor);
29779 tsubst_flags_t complain = tf_none;
29784 init = reshape_init (template_type, init, complain);
29800 parms = tsubst (parms, DECL_TI_ARGS (tmpl), complain, init);
29814 tree ftype = finish_decltype_type (field, true, complain);
29827 tree guide = build_deduction_guide (type, parms, NULL_TREE, complain);
29891 tsubst_flags_t complain = tf_warning_or_error;
29943 targs, i, complain);
29956 g = tsubst_decl (DECL_TEMPLATE_RESULT (f), targs, complain);
29971 ci = tsubst_constraint_info (ci, targs, complain, in_decl);
30015 ctor_deduction_guides_for (tree tmpl, tsubst_flags_t complain)
30028 tree guide = build_deduction_guide (type, *iter, outer_args, complain);
30036 complain);
30044 complain);
30059 deduction_guides_for (tree tmpl, bool &any_dguides_p, tsubst_flags_t complain)
30067 complain);
30073 LOOK_want::NORMAL, /*complain*/false);
30101 cands = ctor_deduction_guides_for (tmpl, complain);
30140 int flags, tsubst_flags_t complain)
30170 if (complain & tf_error)
30176 if (complain & tf_error)
30240 args = resolve_args (args, complain);
30245 tree cands = deduction_guides_for (tmpl, any_dguides_p, complain);
30318 if (complain & tf_warning_or_error)
30321 perform_dguide_overload_resolution (cands, args, complain);
30334 if (complain & tf_warning_or_error)
30350 if (fndecl != error_mark_node && !any_dguides_p && (complain & tf_warning))
30384 tsubst_flags_t complain /* = tf_warning_or_error */,
30405 complain &= ~tf_partial;
30409 return do_class_deduction (type, ctmpl, init, flags, complain);
30427 if (complain & tf_warning_or_error)
30448 elt.value = resolve_nondeduced_context (elt.value, complain);
30451 init = resolve_nondeduced_context (init, complain);
30478 tree deduced = finish_decltype_type (init, id, complain);
30479 deduced = canonicalize_type_argument (deduced, complain);
30512 && (complain & tf_error))
30592 if (complain & tf_warning_or_error)
30628 return tsubst (type, targs, complain, NULL_TREE);
Indexes created Mon Apr 27 00:23:16 UTC 2026