| Message ID | 5b89d4fe-88b7-b51b-fc0e-11833bde2c34@oracle.com |
|---|---|
| State | New |
| Headers | show |
| Series | [C++] Improve delete_sanity locations | expand |
On 7/24/19 5:24 PM, Paolo Carlini wrote: > this takes care of the four locations, two warnings and two errors. I'm > also adding the missing complain & tf_warning or tf_error guards, I > don't have a SFINAE testcase failing but since the function takes a > tsubst_flags_t argument I think it's the right thing to do. Tested > x86_64-linux. OK. > By the way, shall we add to cp-tree.h, at least temporarily, a: > > inline location_t > cp_expr_loc_or_loc (const_tree t) > { > return cp_expr_loc_or_loc (t, input_location); > } > > overload? We could use it in a ton of places. I'd call it "cp_expr_loc_or_here". But David removed EXPR_LOC_OR_HERE a few years back, so I'd like him to weigh in. Jason
On Wed, 2019-07-31 at 15:14 -0400, Jason Merrill wrote: > On 7/24/19 5:24 PM, Paolo Carlini wrote: > > this takes care of the four locations, two warnings and two errors. > > I'm > > also adding the missing complain & tf_warning or tf_error guards, > > I > > don't have a SFINAE testcase failing but since the function takes > > a > > tsubst_flags_t argument I think it's the right thing to do. Tested > > x86_64-linux. > > OK. > > > By the way, shall we add to cp-tree.h, at least temporarily, a: > > > > inline location_t > > cp_expr_loc_or_loc (const_tree t) > > { > > return cp_expr_loc_or_loc (t, input_location); > > } > > > > overload? We could use it in a ton of places. > > I'd call it "cp_expr_loc_or_here". But David removed > EXPR_LOC_OR_HERE a > few years back, so I'd like him to weigh in. I don't care for "cp_expr_loc_or_loc". By "_or_here" do you mean "or input_location"? Calling it "cp_expr_loc_or_input_location" would spell out what it does, but would be rather long. Dave
Hi, On 31/07/19 21:39, David Malcolm wrote: [snip] > I don't care for "cp_expr_loc_or_loc". > > By "_or_here" do you mean "or input_location"? > > Calling it "cp_expr_loc_or_input_location" would spell out what it > does, but would be rather long. Thanks for your feedback. At this point I don't feel very strongly about the issue, and, well, hopefully it's just temporary material, but I tested the below which proposes the name cp_expr_loc_or_input_loc. Seems a good balance to me. What do you think? Cheers, Paolo. ///////////////// Index: call.c =================================================================== --- call.c (revision 274001) +++ call.c (working copy) @@ -4184,7 +4184,7 @@ build_converted_constant_expr_internal (tree type, conversion *conv; void *p; tree t; - location_t loc = cp_expr_loc_or_loc (expr, input_location); + location_t loc = cp_expr_loc_or_input_loc (expr); if (error_operand_p (expr)) return error_mark_node; @@ -6961,7 +6961,7 @@ convert_like_real (conversion *convs, tree expr, t tree totype = convs->type; diagnostic_t diag_kind; int flags; - location_t loc = cp_expr_loc_or_loc (expr, input_location); + location_t loc = cp_expr_loc_or_input_loc (expr); if (convs->bad_p && !(complain & tf_error)) return error_mark_node; @@ -7481,7 +7481,7 @@ tree convert_arg_to_ellipsis (tree arg, tsubst_flags_t complain) { tree arg_type; - location_t loc = cp_expr_loc_or_loc (arg, input_location); + location_t loc = cp_expr_loc_or_input_loc (arg); /* [expr.call] @@ -7789,7 +7789,7 @@ convert_for_arg_passing (tree type, tree val, tsub "argument of function call might be a candidate " "for a format attribute"); } - maybe_warn_parm_abi (type, cp_expr_loc_or_loc (val, input_location)); + maybe_warn_parm_abi (type, cp_expr_loc_or_input_loc (val)); } if (complain & tf_warning) @@ -8595,7 +8595,7 @@ build_over_call (struct z_candidate *cand, int fla tree type = TREE_TYPE (to); tree as_base = CLASSTYPE_AS_BASE (type); tree arg = argarray[1]; - location_t loc = cp_expr_loc_or_loc (arg, input_location); + location_t loc = cp_expr_loc_or_input_loc (arg); if (is_really_empty_class (type, /*ignore_vptr*/true)) { @@ -9143,7 +9143,7 @@ build_cxx_call (tree fn, int nargs, tree *argarray tree fndecl; /* Remember roughly where this call is. */ - location_t loc = cp_expr_loc_or_loc (fn, input_location); + location_t loc = cp_expr_loc_or_input_loc (fn); fn = build_call_a (fn, nargs, argarray); SET_EXPR_LOCATION (fn, loc); @@ -11183,7 +11183,7 @@ perform_implicit_conversion_flags (tree type, tree { conversion *conv; void *p; - location_t loc = cp_expr_loc_or_loc (expr, input_location); + location_t loc = cp_expr_loc_or_input_loc (expr); if (TYPE_REF_P (type)) expr = mark_lvalue_use (expr); @@ -11532,7 +11532,7 @@ initialize_reference (tree type, tree expr, { conversion *conv; void *p; - location_t loc = cp_expr_loc_or_loc (expr, input_location); + location_t loc = cp_expr_loc_or_input_loc (expr); if (type == error_mark_node || error_operand_p (expr)) return error_mark_node; Index: constexpr.c =================================================================== --- constexpr.c (revision 274001) +++ constexpr.c (working copy) @@ -1527,7 +1527,7 @@ cxx_eval_internal_function (const constexpr_ctx *c default: if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "call to internal function %qE", t); *non_constant_p = true; return t; @@ -1542,7 +1542,7 @@ cxx_eval_internal_function (const constexpr_ctx *c if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST) { - location_t loc = cp_expr_loc_or_loc (t, input_location); + location_t loc = cp_expr_loc_or_input_loc (t); tree type = TREE_TYPE (TREE_TYPE (t)); tree result = fold_binary_loc (loc, opcode, type, fold_convert_loc (loc, type, arg0), @@ -1584,7 +1584,7 @@ cxx_eval_call_expression (const constexpr_ctx *ctx bool lval, bool *non_constant_p, bool *overflow_p) { - location_t loc = cp_expr_loc_or_loc (t, input_location); + location_t loc = cp_expr_loc_or_input_loc (t); tree fun = get_function_named_in_call (t); constexpr_call new_call = { NULL, NULL, NULL, 0, ctx->manifestly_const_eval }; @@ -2580,7 +2580,7 @@ eval_and_check_array_index (const constexpr_ctx *c tree t, bool allow_one_past, bool *non_constant_p, bool *overflow_p) { - location_t loc = cp_expr_loc_or_loc (t, input_location); + location_t loc = cp_expr_loc_or_input_loc (t); tree ary = TREE_OPERAND (t, 0); t = TREE_OPERAND (t, 1); tree index = cxx_eval_constant_expression (ctx, t, false, @@ -3909,7 +3909,7 @@ cxx_eval_store_expression (const constexpr_ctx *ct if (cxx_dialect < cxx2a) { if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "change of the active member of a union " "from %qD to %qD", CONSTRUCTOR_ELT (*valp, 0)->index, @@ -4220,7 +4220,7 @@ cxx_eval_statement_list (const constexpr_ctx *ctx, /* We aren't communicating the jump to our caller, so give up. We don't need to support evaluation of jumps out of statement-exprs. */ if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (r, input_location), + error_at (cp_expr_loc_or_input_loc (r), "statement is not a constant expression"); *non_constant_p = true; } @@ -4320,7 +4320,7 @@ cxx_eval_loop_expr (const constexpr_ctx *ctx, tree if (++count >= constexpr_loop_limit) { if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "%<constexpr%> loop iteration count exceeds limit of %d " "(use %<-fconstexpr-loop-limit=%> to increase the limit)", constexpr_loop_limit); @@ -4482,7 +4482,7 @@ cxx_eval_constant_expression (const constexpr_ctx if (++*ctx->constexpr_ops_count >= constexpr_ops_limit) { if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "%<constexpr%> evaluation operation count exceeds limit of " "%wd (use %<-fconstexpr-ops-limit=%> to increase the limit)", constexpr_ops_limit); @@ -5036,7 +5036,7 @@ cxx_eval_constant_expression (const constexpr_ctx if (REINTERPRET_CAST_P (t)) { if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "%<reinterpret_cast%> is not a constant expression"); *non_constant_p = true; return t; @@ -5077,7 +5077,7 @@ cxx_eval_constant_expression (const constexpr_ctx if (TYPE_REF_P (type)) { if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "dereferencing a null pointer"); *non_constant_p = true; return t; @@ -5089,7 +5089,7 @@ cxx_eval_constant_expression (const constexpr_ctx if (!can_convert (type, from, tf_none)) { if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "conversion of %qT null pointer to %qT " "is not a constant expression", from, type); @@ -5104,7 +5104,7 @@ cxx_eval_constant_expression (const constexpr_ctx reinterpret_cast<void*>(sizeof 0) */ if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "%<reinterpret_cast<%T>(%E)%> is not " "a constant expression", type, op); @@ -5178,7 +5178,7 @@ cxx_eval_constant_expression (const constexpr_ctx case BASELINK: case OFFSET_REF: if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "expression %qE is not a constant expression", t); *non_constant_p = true; break; @@ -5196,7 +5196,7 @@ cxx_eval_constant_expression (const constexpr_ctx || !DECL_P (get_base_address (TREE_OPERAND (obj, 0)))) { if (!ctx->quiet) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "expression %qE is not a constant expression", t); *non_constant_p = true; return t; @@ -5960,7 +5960,7 @@ potential_constant_expression_1 (tree t, bool want return false; if (t == NULL_TREE) return true; - location_t loc = cp_expr_loc_or_loc (t, input_location); + location_t loc = cp_expr_loc_or_input_loc (t); if (*jump_target) /* If we are jumping, ignore everything. This is simpler than the Index: constraint.cc =================================================================== --- constraint.cc (revision 274001) +++ constraint.cc (working copy) @@ -805,7 +805,7 @@ check_for_logical_overloads (tree t) if (DECL_OVERLOADED_OPERATOR_P (fn)) { - location_t loc = cp_expr_loc_or_loc (t, input_location); + location_t loc = cp_expr_loc_or_input_loc (t); error_at (loc, "constraint %qE, uses overloaded operator", t); return true; } @@ -2016,7 +2016,7 @@ satisfy_predicate_constraint (tree t, tree args, tree type = cv_unqualified (TREE_TYPE (expr)); if (!same_type_p (type, boolean_type_node)) { - error_at (cp_expr_loc_or_loc (expr, input_location), + error_at (cp_expr_loc_or_input_loc (expr), "constraint %qE does not have type %qT", expr, boolean_type_node); return boolean_false_node; Index: cp-gimplify.c =================================================================== --- cp-gimplify.c (revision 274001) +++ cp-gimplify.c (working copy) @@ -644,7 +644,7 @@ int cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) { int saved_stmts_are_full_exprs_p = 0; - location_t loc = cp_expr_loc_or_loc (*expr_p, input_location); + location_t loc = cp_expr_loc_or_input_loc (*expr_p); enum tree_code code = TREE_CODE (*expr_p); enum gimplify_status ret; Index: cp-tree.h =================================================================== --- cp-tree.h (revision 274001) +++ cp-tree.h (working copy) @@ -7509,11 +7509,17 @@ cp_expr_loc_or_loc (const_tree t, location_t or_lo return loc; } +inline location_t +cp_expr_loc_or_input_loc (const_tree t) +{ + return cp_expr_loc_or_loc (t, input_location); +} + inline void cxx_incomplete_type_diagnostic (const_tree value, const_tree type, diagnostic_t diag_kind) { - cxx_incomplete_type_diagnostic (cp_expr_loc_or_loc (value, input_location), + cxx_incomplete_type_diagnostic (cp_expr_loc_or_input_loc (value), value, type, diag_kind); } Index: cvt.c =================================================================== --- cvt.c (revision 274001) +++ cvt.c (working copy) @@ -77,7 +77,7 @@ cp_convert_to_pointer (tree type, tree expr, bool tree intype = TREE_TYPE (expr); enum tree_code form; tree rval; - location_t loc = cp_expr_loc_or_loc (expr, input_location); + location_t loc = cp_expr_loc_or_input_loc (expr); if (intype == error_mark_node) return error_mark_node; @@ -419,7 +419,7 @@ convert_to_reference (tree reftype, tree expr, int tree rval = NULL_TREE; tree rval_as_conversion = NULL_TREE; bool can_convert_intype_to_type; - location_t loc = cp_expr_loc_or_loc (expr, input_location); + location_t loc = cp_expr_loc_or_input_loc (expr); if (TREE_CODE (type) == FUNCTION_TYPE && TREE_TYPE (expr) == unknown_type_node) @@ -671,7 +671,7 @@ cp_convert_and_check (tree type, tree expr, tsubst folded_result = fold_simple (folded_result); if (!TREE_OVERFLOW_P (folded) && folded_result != error_mark_node) - warnings_for_convert_and_check (cp_expr_loc_or_loc (expr, input_location), + warnings_for_convert_and_check (cp_expr_loc_or_input_loc (expr), type, folded, folded_result); } @@ -690,7 +690,7 @@ ocp_convert (tree type, tree expr, int convtype, i enum tree_code code = TREE_CODE (type); const char *invalid_conv_diag; tree e1; - location_t loc = cp_expr_loc_or_loc (expr, input_location); + location_t loc = cp_expr_loc_or_input_loc (expr); bool dofold = (convtype & CONV_FOLD); if (error_operand_p (e) || type == error_mark_node) @@ -1013,7 +1013,7 @@ maybe_warn_nodiscard (tree expr, impl_conv_void im tree call = expr; if (TREE_CODE (expr) == TARGET_EXPR) call = TARGET_EXPR_INITIAL (expr); - location_t loc = cp_expr_loc_or_loc (call, input_location); + location_t loc = cp_expr_loc_or_input_loc (call); tree callee = cp_get_callee (call); if (!callee) return; @@ -1093,7 +1093,7 @@ maybe_warn_nodiscard (tree expr, impl_conv_void im tree convert_to_void (tree expr, impl_conv_void implicit, tsubst_flags_t complain) { - location_t loc = cp_expr_loc_or_loc (expr, input_location); + location_t loc = cp_expr_loc_or_input_loc (expr); if (expr == error_mark_node || TREE_TYPE (expr) == error_mark_node) Index: decl.c =================================================================== --- decl.c (revision 274001) +++ decl.c (working copy) @@ -3560,7 +3560,7 @@ pop_switch (void) location_t switch_location; /* Emit warnings as needed. */ - switch_location = cp_expr_loc_or_loc (cs->switch_stmt, input_location); + switch_location = cp_expr_loc_or_input_loc (cs->switch_stmt); const bool bool_cond_p = (SWITCH_STMT_TYPE (cs->switch_stmt) && TREE_CODE (SWITCH_STMT_TYPE (cs->switch_stmt)) == BOOLEAN_TYPE); Index: decl2.c =================================================================== --- decl2.c (revision 274001) +++ decl2.c (working copy) @@ -489,7 +489,7 @@ delete_sanity (tree exp, tree size, bool doing_vec /* An array can't have been allocated by new, so complain. */ if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE && (complain & tf_warning)) - warning_at (cp_expr_loc_or_loc (exp, input_location), 0, + warning_at (cp_expr_loc_or_input_loc (exp), 0, "deleting array %q#E", exp); t = build_expr_type_conversion (WANT_POINTER, exp, true); @@ -497,7 +497,7 @@ delete_sanity (tree exp, tree size, bool doing_vec if (t == NULL_TREE || t == error_mark_node) { if (complain & tf_error) - error_at (cp_expr_loc_or_loc (exp, input_location), + error_at (cp_expr_loc_or_input_loc (exp), "type %q#T argument given to %<delete%>, expected pointer", TREE_TYPE (exp)); return error_mark_node; @@ -511,7 +511,7 @@ delete_sanity (tree exp, tree size, bool doing_vec if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) { if (complain & tf_error) - error_at (cp_expr_loc_or_loc (exp, input_location), + error_at (cp_expr_loc_or_input_loc (exp), "cannot delete a function. Only pointer-to-objects are " "valid arguments to %<delete%>"); return error_mark_node; @@ -521,8 +521,7 @@ delete_sanity (tree exp, tree size, bool doing_vec if (VOID_TYPE_P (TREE_TYPE (type))) { if (complain & tf_warning) - warning_at (cp_expr_loc_or_loc (exp, input_location), - OPT_Wdelete_incomplete, + warning_at (cp_expr_loc_or_input_loc (exp), OPT_Wdelete_incomplete, "deleting %qT is undefined", type); doing_vec = 0; } Index: error.c =================================================================== --- error.c (revision 274001) +++ error.c (working copy) @@ -3053,7 +3053,7 @@ location_of (tree t) return DECL_SOURCE_LOCATION (t); if (TREE_CODE (t) == DEFERRED_PARSE) return defparse_location (t); - return cp_expr_loc_or_loc (t, input_location); + return cp_expr_loc_or_input_loc (t); } /* Now the interfaces from error et al to dump_type et al. Each takes an Index: init.c =================================================================== --- init.c (revision 274001) +++ init.c (working copy) @@ -749,7 +749,7 @@ maybe_warn_list_ctor (tree member, tree init) if (!begin) return; - location_t loc = cp_expr_loc_or_loc (init, input_location); + location_t loc = cp_expr_loc_or_input_loc (init); warning_at (loc, OPT_Winit_list_lifetime, "initializing %qD from %qE does not extend the lifetime " "of the underlying array", member, begin); @@ -1749,7 +1749,7 @@ build_aggr_init (tree exp, tree init, int flags, t return error_mark_node; location_t init_loc = (init - ? cp_expr_loc_or_loc (init, input_location) + ? cp_expr_loc_or_input_loc (init) : location_of (exp)); TREE_READONLY (exp) = 0; @@ -2578,7 +2578,7 @@ find_flexarray_init (tree t, tree init) static void warn_placement_new_too_small (tree type, tree nelts, tree size, tree oper) { - location_t loc = cp_expr_loc_or_loc (oper, input_location); + location_t loc = cp_expr_loc_or_input_loc (oper); /* The number of bytes to add to or subtract from the size of the provided buffer based on an offset into an array or an array element reference. @@ -2975,7 +2975,7 @@ build_new_1 (vec<tree, va_gc> **placement, tree ty { if (complain & tf_error) { - error_at (cp_expr_loc_or_loc (inner_nelts, input_location), + error_at (cp_expr_loc_or_input_loc (inner_nelts), "array size in new-expression must be constant"); cxx_constant_value(inner_nelts); } @@ -3004,7 +3004,7 @@ build_new_1 (vec<tree, va_gc> **placement, tree ty { if (complain & tf_warning_or_error) { - pedwarn (cp_expr_loc_or_loc (outer_nelts, input_location), OPT_Wvla, + pedwarn (cp_expr_loc_or_input_loc (outer_nelts), OPT_Wvla, typedef_variant_p (orig_type) ? G_("non-constant array new length must be specified " "directly, not by %<typedef%>") @@ -4140,7 +4140,7 @@ build_vec_init (tree base, tree maxindex, tree ini tree obase = base; bool xvalue = false; bool errors = false; - location_t loc = (init ? cp_expr_loc_or_loc (init, input_location) + location_t loc = (init ? cp_expr_loc_or_input_loc (init) : location_of (base)); if (TREE_CODE (atype) == ARRAY_TYPE && TYPE_DOMAIN (atype)) Index: lex.c =================================================================== --- lex.c (revision 274001) +++ lex.c (working copy) @@ -502,7 +502,7 @@ tree unqualified_name_lookup_error (tree name, location_t loc) { if (loc == UNKNOWN_LOCATION) - loc = cp_expr_loc_or_loc (name, input_location); + loc = cp_expr_loc_or_input_loc (name); if (IDENTIFIER_ANY_OP_P (name)) error_at (loc, "%qD not defined", name); Index: parser.c =================================================================== --- parser.c (revision 274001) +++ parser.c (working copy) @@ -23122,7 +23122,7 @@ cp_parser_initializer_list (cp_parser* parser, boo { if (IDENTIFIER_MARKED (designator)) { - error_at (cp_expr_loc_or_loc (val, input_location), + error_at (cp_expr_loc_or_input_loc (val), "%<.%s%> designator used multiple times in " "the same initializer list", IDENTIFIER_POINTER (designator)); @@ -36632,7 +36632,7 @@ cp_parser_omp_for_cond (cp_parser *parser, tree de || CLASS_TYPE_P (TREE_TYPE (decl)))) return cond; - return build_x_binary_op (cp_expr_loc_or_loc (cond, input_location), + return build_x_binary_op (cp_expr_loc_or_input_loc (cond), TREE_CODE (cond), TREE_OPERAND (cond, 0), ERROR_MARK, TREE_OPERAND (cond, 1), ERROR_MARK, Index: pt.c =================================================================== --- pt.c (revision 274001) +++ pt.c (working copy) @@ -4059,7 +4059,7 @@ check_for_bare_parameter_packs (tree t, location_t if (parameter_packs) { if (loc == UNKNOWN_LOCATION) - loc = cp_expr_loc_or_loc (t, input_location); + loc = cp_expr_loc_or_input_loc (t); error_at (loc, "parameter packs not expanded with %<...%>:"); while (parameter_packs) { @@ -6306,7 +6306,7 @@ static bool check_valid_ptrmem_cst_expr (tree type, tree expr, tsubst_flags_t complain) { - location_t loc = cp_expr_loc_or_loc (expr, input_location); + location_t loc = cp_expr_loc_or_input_loc (expr); tree orig_expr = expr; STRIP_NOPS (expr); if (null_ptr_cst_p (expr)) @@ -6525,7 +6525,7 @@ unify_arg_conversion (bool explain_p, tree to_type tree from_type, tree arg) { if (explain_p) - inform (cp_expr_loc_or_loc (arg, input_location), + inform (cp_expr_loc_or_input_loc (arg), " cannot convert %qE (type %qT) to type %qT", arg, from_type, to_type); return unify_invalid (explain_p); @@ -6765,7 +6765,7 @@ static tree convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain) { tree expr_type; - location_t loc = cp_expr_loc_or_loc (expr, input_location); + location_t loc = cp_expr_loc_or_input_loc (expr); /* Detect immediately string literals as invalid non-type argument. This special-case is not needed for correctness (we would easily @@ -18965,10 +18965,10 @@ tsubst_copy_and_build (tree t, bool diag = true; if (in_lambda) - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), msg, function); else - diag = permerror (cp_expr_loc_or_loc (t, input_location), + diag = permerror (cp_expr_loc_or_input_loc (t), msg, function); if (diag) { @@ -18983,8 +18983,7 @@ tsubst_copy_and_build (tree t, /* Can't say anything more. */; else if (DECL_CLASS_SCOPE_P (fn)) { - location_t loc = cp_expr_loc_or_loc (t, - input_location); + location_t loc = cp_expr_loc_or_input_loc (t); inform (loc, "declarations in dependent base %qT are " "not found by unqualified lookup", @@ -19032,14 +19031,13 @@ tsubst_copy_and_build (tree t, gcc_assert (nargs == 1); if (vec_safe_length (call_args) != 1) { - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "wrong number of arguments to " "%<__builtin_launder%>"); ret = error_mark_node; } else - ret = finish_builtin_launder (cp_expr_loc_or_loc (t, - input_location), + ret = finish_builtin_launder (cp_expr_loc_or_input_loc (t), (*call_args)[0], complain); break; @@ -19047,7 +19045,7 @@ tsubst_copy_and_build (tree t, gcc_assert (nargs == 1); if (vec_safe_length (call_args) != 1) { - error_at (cp_expr_loc_or_loc (t, input_location), + error_at (cp_expr_loc_or_input_loc (t), "wrong number of arguments to " "%<__builtin_convertvector%>"); ret = error_mark_node; @@ -26595,7 +26593,7 @@ resolve_typename_type (tree type, bool only_curren [temp.names]: In a qualified-id of a declarator-id, the keyword template shall not appear at the top level. */ - pedwarn (cp_expr_loc_or_loc (fullname, input_location), OPT_Wpedantic, + pedwarn (cp_expr_loc_or_input_loc (fullname), OPT_Wpedantic, "keyword %<template%> not allowed in declarator-id"); tmpl = decl; } Index: semantics.c =================================================================== --- semantics.c (revision 274001) +++ semantics.c (working copy) @@ -658,7 +658,7 @@ maybe_convert_cond (tree cond) if (TREE_CODE (cond) == MODIFY_EXPR && !TREE_NO_WARNING (cond) && warn_parentheses - && warning_at (cp_expr_loc_or_loc (cond, input_location), + && warning_at (cp_expr_loc_or_input_loc (cond), OPT_Wparentheses, "suggest parentheses around " "assignment used as truth value")) TREE_NO_WARNING (cond) = 1; @@ -2426,7 +2426,7 @@ finish_call_expr (tree fn, vec<tree, va_gc> **args || any_type_dependent_arguments_p (*args)) { result = build_min_nt_call_vec (orig_fn, *args); - SET_EXPR_LOCATION (result, cp_expr_loc_or_loc (fn, input_location)); + SET_EXPR_LOCATION (result, cp_expr_loc_or_input_loc (fn)); KOENIG_LOOKUP_P (result) = koenig_p; if (is_overloaded_fn (fn)) fn = get_fns (fn); @@ -10102,7 +10102,7 @@ cp_build_vec_convert (tree arg, location_t loc, tr tree ret = NULL_TREE; if (!type_dependent_expression_p (arg) && !dependent_type_p (type)) - ret = c_build_vec_convert (cp_expr_loc_or_loc (arg, input_location), arg, + ret = c_build_vec_convert (cp_expr_loc_or_input_loc (arg), arg, loc, type, (complain & tf_error) != 0); if (!processing_template_decl) Index: typeck.c =================================================================== --- typeck.c (revision 274001) +++ typeck.c (working copy) @@ -2020,7 +2020,7 @@ decay_conversion (tree exp, { tree type; enum tree_code code; - location_t loc = cp_expr_loc_or_loc (exp, input_location); + location_t loc = cp_expr_loc_or_input_loc (exp); type = TREE_TYPE (exp); if (type == error_mark_node) @@ -2281,7 +2281,7 @@ static tree rationalize_conditional_expr (enum tree_code code, tree t, tsubst_flags_t complain) { - location_t loc = cp_expr_loc_or_loc (t, input_location); + location_t loc = cp_expr_loc_or_input_loc (t); /* 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 @@ -6206,7 +6206,7 @@ cp_build_unary_op (enum tree_code code, tree xarg, { /* No default_conversion here. It causes trouble for ADDR_EXPR. */ tree arg = xarg; - location_t location = cp_expr_loc_or_loc (arg, input_location); + location_t location = cp_expr_loc_or_input_loc (arg); tree argtype = 0; const char *errstring = NULL; tree val; @@ -6760,7 +6760,7 @@ build_x_compound_expr_from_list (tree list, expr_l && !CONSTRUCTOR_IS_DIRECT_INIT (expr)) { if (complain & tf_error) - pedwarn (cp_expr_loc_or_loc (expr, input_location), 0, + pedwarn (cp_expr_loc_or_input_loc (expr), 0, "list-initializer for non-class type must not " "be parenthesized"); else @@ -9210,7 +9210,7 @@ maybe_warn_about_returning_address_of_local (tree { tree valtype = TREE_TYPE (DECL_RESULT (current_function_decl)); tree whats_returned = fold_for_warn (retval); - location_t loc = cp_expr_loc_or_loc (retval, input_location); + location_t loc = cp_expr_loc_or_input_loc (retval); for (;;) { @@ -9420,7 +9420,7 @@ maybe_warn_pessimizing_move (tree retval, tree fun if (!(warn_pessimizing_move || warn_redundant_move)) return; - location_t loc = cp_expr_loc_or_loc (retval, input_location); + location_t loc = cp_expr_loc_or_input_loc (retval); /* C++98 doesn't know move. */ if (cxx_dialect < cxx11) Index: typeck2.c =================================================================== --- typeck2.c (revision 274001) +++ typeck2.c (working copy) @@ -1006,7 +1006,7 @@ check_narrowing (tree type, tree init, tsubst_flag if (!ok) { - location_t loc = cp_expr_loc_or_loc (init, input_location); + location_t loc = cp_expr_loc_or_input_loc (init); if (cxx_dialect == cxx98) { if (complain & tf_warning) @@ -1085,7 +1085,7 @@ digest_init_r (tree type, tree init, int nested, i complain)) return error_mark_node; - location_t loc = cp_expr_loc_or_loc (init, input_location); + location_t loc = cp_expr_loc_or_input_loc (init); tree stripped_init = init; @@ -1402,7 +1402,7 @@ process_init_constructor_array (tree type, tree in if (nested == 2 && !domain && !vec_safe_is_empty (v)) { if (complain & tf_error) - error_at (cp_expr_loc_or_loc (init, input_location), + error_at (cp_expr_loc_or_input_loc (init), "initialization of flexible array member " "in a nested context"); return PICFLAG_ERRONEOUS;
On Fri, 2019-08-02 at 14:02 +0200, Paolo Carlini wrote: > Hi, > > On 31/07/19 21:39, David Malcolm wrote: > > [snip] > > I don't care for "cp_expr_loc_or_loc". > > > > By "_or_here" do you mean "or input_location"? > > > > Calling it "cp_expr_loc_or_input_location" would spell out what it > > does, but would be rather long. > > Thanks for your feedback. At this point I don't feel very strongly > about > the issue, and, well, hopefully it's just temporary material, but I > tested the below which proposes the name cp_expr_loc_or_input_loc. > Seems > a good balance to me. What do you think? I like it, FWIW. Thanks Dave
On 8/2/19 8:27 AM, David Malcolm wrote: > On Fri, 2019-08-02 at 14:02 +0200, Paolo Carlini wrote: >> Hi, >> >> On 31/07/19 21:39, David Malcolm wrote: >> >> [snip] >>> I don't care for "cp_expr_loc_or_loc". >>> >>> By "_or_here" do you mean "or input_location"? >>> >>> Calling it "cp_expr_loc_or_input_location" would spell out what it >>> does, but would be rather long. >> >> Thanks for your feedback. At this point I don't feel very strongly >> about >> the issue, and, well, hopefully it's just temporary material, but I >> tested the below which proposes the name cp_expr_loc_or_input_loc. >> Seems >> a good balance to me. What do you think? > > I like it, FWIW. OK. Jason
Index: cp/decl2.c =================================================================== --- cp/decl2.c (revision 273767) +++ cp/decl2.c (working copy) @@ -487,15 +487,19 @@ delete_sanity (tree exp, tree size, bool doing_vec } /* An array can't have been allocated by new, so complain. */ - if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE) - warning (0, "deleting array %q#E", exp); + if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE + && (complain & tf_warning)) + warning_at (cp_expr_loc_or_loc (exp, input_location), 0, + "deleting array %q#E", exp); t = build_expr_type_conversion (WANT_POINTER, exp, true); if (t == NULL_TREE || t == error_mark_node) { - error ("type %q#T argument given to %<delete%>, expected pointer", - TREE_TYPE (exp)); + if (complain & tf_error) + error_at (cp_expr_loc_or_loc (exp, input_location), + "type %q#T argument given to %<delete%>, expected pointer", + TREE_TYPE (exp)); return error_mark_node; } @@ -506,8 +510,10 @@ delete_sanity (tree exp, tree size, bool doing_vec /* You can't delete functions. */ if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) { - error ("cannot delete a function. Only pointer-to-objects are " - "valid arguments to %<delete%>"); + if (complain & tf_error) + error_at (cp_expr_loc_or_loc (exp, input_location), + "cannot delete a function. Only pointer-to-objects are " + "valid arguments to %<delete%>"); return error_mark_node; } @@ -514,7 +520,10 @@ delete_sanity (tree exp, tree size, bool doing_vec /* Deleting ptr to void is undefined behavior [expr.delete/3]. */ if (VOID_TYPE_P (TREE_TYPE (type))) { - warning (OPT_Wdelete_incomplete, "deleting %qT is undefined", type); + if (complain & tf_warning) + warning_at (cp_expr_loc_or_loc (exp, input_location), + OPT_Wdelete_incomplete, + "deleting %qT is undefined", type); doing_vec = 0; } Index: testsuite/g++.dg/diagnostic/delete1.C =================================================================== --- testsuite/g++.dg/diagnostic/delete1.C (nonexistent) +++ testsuite/g++.dg/diagnostic/delete1.C (working copy) @@ -0,0 +1,14 @@ +void f () +{ + int a[1]; + delete (a); // { dg-warning "11:deleting array" } + + bool b; + delete (b); // { dg-error "11:type .bool. argument" } + + void g (); + delete (g); // { dg-error "11:cannot delete a function" } + + void* p; + delete (p); // { dg-warning "11:deleting .void*." } +}
Hi, this takes care of the four locations, two warnings and two errors. I'm also adding the missing complain & tf_warning or tf_error guards, I don't have a SFINAE testcase failing but since the function takes a tsubst_flags_t argument I think it's the right thing to do. Tested x86_64-linux. By the way, shall we add to cp-tree.h, at least temporarily, a: inline location_t cp_expr_loc_or_loc (const_tree t) { return cp_expr_loc_or_loc (t, input_location); } overload? We could use it in a ton of places. Thanks, Paolo. ////////////////////////// /cp 2019-07-24 Paolo Carlini <paolo.carlini@oracle.com> * decl2.c (delete_sanity): Improve diagnostic locations, use cp_expr_loc_or_loc in four places. /testsuite 2019-07-24 Paolo Carlini <paolo.carlini@oracle.com> * g++.dg/diagnostic/delete1.C: New.