C++ FE: expression ranges

gcc/ChangeLog:
	* convert.c (convert_to_real_1): When converting from a
	REAL_TYPE, preserve the location of EXPR in the result.
	* tree.c (get_pure_location): Make non-static.
	(set_source_range): Return the resulting location_t.
	(make_location): New function.
	* tree.h (get_pure_location): New decl.
	(get_finish): New inline function.
	(set_source_range): Convert return type from void to location_t.
	(make_location): New decl.

gcc/cp/ChangeLog:
	* cp-tree.h (class cp_expr): New class.
	(finish_parenthesized_expr): Convert return type and param to
	cp_expr.
	(perform_koenig_lookup): Convert return type and param from tree
	to cp_expr.
	(finish_increment_expr): Likewise.
	(finish_unary_op_expr): Likewise.
	(finish_id_expression): Likewise for return type.
	(build_class_member_access_expr): Likewise for param.
	(finish_class_member_access_expr): Likewise.
	(build_x_unary_op): Likewise.
	(build_c_cast): New decl.
	(build_x_modify_expr): Convert return type from tree to cp_expr.
	* cvt.c (cp_convert_and_check): When warning about conversions,
	attempt to use the location of "expr" if available, otherwise
	falling back to the old behavior of using input_location.
	* name-lookup.c (lookup_arg_dependent_1): Convert return type from
	tree to cp_expr.
	(lookup_arg_dependent): Likewise; also for local "ret".
	* name-lookup.h (lookup_arg_dependent): Likewise for return type.
	* parser.c (cp_lexer_previous_token): Skip past purged tokens.
	(struct cp_parser_expression_stack_entry): Convert field "lhs" to
	cp_expr.
	(cp_parser_identifier): Likewise for return type.  Use cp_expr
	ctor to preserve the token's location.
	(cp_parser_string_literal): Likewise, building up a meaningful
	location for the case where a compound string literal is built by
	concatentation.
	(cp_parser_userdef_char_literal): Likewise for return type.
	(cp_parser_userdef_numeric_literal): Likewise.
	(cp_parser_statement_expr): Convert return type to cp_expr.
	Generate a suitable location for the expr and return it via the
	cp_expr ctor.
	(cp_parser_fold_expression): Convert return type to cp_expr.
	(cp_parser_primary_expression): Likewise, and for locals "expr",
	"lam", "id_expression", "decl".
	Use cp_expr ctor when parsing literals, to preserve the spelling
	location of the token.  Preserve the locations of parentheses.
	Preserve location when calling objc_lookup_ivar.
	Preserve the location for "this" tokens.  Generate suitable
	locations for "__builtin_va_arg" constructs and for
	Objective C 2.0 dot-syntax.  Set the location for the result of
	finish_id_expression.
	(cp_parser_primary_expression): Convert return type from tree to
	cp_expr.
	(cp_parser_id_expression): Likewise.
	(cp_parser_unqualified_id): Likewise.  Also for local "id".
	(cp_parser_postfix_expression): Likewise, also for local
	"postfix_expression".  Generate suitable locations for
	C++-style casts, "_Cilk_spawn" constructs.  Convert local
	"initializer" to cp_expr and use it to preserve the location of
	compound literals.  Capture the location of the closing
	parenthesis of a call site via
	cp_parser_parenthesized_expression_list, and use it to build
	a source range for a call.  Use cp_expr in ternary expression.
	(cp_parser_postfix_dot_deref_expression): Convert param from tree to
	cp_expr.  Generate and set a location.
	(cp_parser_parenthesized_expression_list): Add "close_paren_loc"
	out-param, and write back to it.
	(cp_parser_unary_expression): Convert return type from tree to
	cp_expr.  Also for locals "cast_expression" and "expression".
	Generate and use suitable locations for addresses of
	labels and for cast expressions.  Call cp_expr::set_location where
	necessary.  Preserve the locations of negated numeric literals.
	(cp_parser_new_expression): Generate meaningful locations/ranges.
	(cp_parser_cast_expression): Convert return type from tree to
	cp_expr; also for local "expr".  Use the paren location to generate a
	meaningful range for the expression.
	(cp_parser_binary_expression): Convert return type from tree to
	cp_expr; also for local "rhs".  Generate a meaningful location
	for the expression, and use it.  Replace call to
	protected_set_expr_location by converting a build2 to a build2_loc
	and using the location in the call to build_x_binary_op, adding a
	cp_expr::set_location to the latter case.
	(cp_parser_question_colon_clause): Convert param from tree to
	cp_expr; also for local "assignment_expr".  Set the spelling range
	of the expression.
	(cp_parser_assignment_expression): Likewise for return type and
	locals "expr" and "rhs".  Build a meaningful spelling range for
	the expression.  Remove saving of input_location in favor of a
	call to cp_expr::set_location.
	(cp_parser_expression): Convert return type and locals
	"expression" and "assignment_expression" to cp_expr.  Build a
	meaningful spelling range for assignment expressions.
	(cp_parser_constant_expression): Likewise for return type and
	local "expression".
	(cp_parser_builtin_offsetof): Convert return type and local "expr"
	to cp_expr.  Generate suitable locations.
	(cp_parser_lambda_expression): Convert return return type to
	cp_expr.
	(cp_parser_operator_function_id): Likewise.
	(cp_parser_operator): Likewise.  Generate a meaningful range,
	using cp_expr's ctor to return it.
	(cp_parser_template_id): When converting a token to
	CPP_TEMPLATE_ID, update the location.
	(cp_parser_initializer_clause): Convert return type and local
	"initializer" to cp_expr.
	(cp_parser_braced_list): Likewise for return type.  Generate
	suitable locations.
	(cp_parser_lookup_name): Likewise for return type.  Use cp_expr's
	ctor to preserve the location_t of the name.
	(cp_parser_simple_cast_expression): Likewise for return type.
	(cp_parser_functional_cast): Convert return type and local "cast"
	to cp_expr.  Generate suitable locations.
	(cp_parser_objc_expression): Convert return type to cp_expr.k  Generate
	(cp_parser_objc_message_expression): Generate suitable locations.
	(cp_parser_objc_encode_expression): Convert return type to
	cp_expr.  Generate suitable locations.
	(cp_parser_objc_protocol_expression): Generate suitable locations.
	(cp_parser_objc_selector_expression): Generate suitable locations.
	(cp_parser_omp_for_cond): Attempt to use the location
	of "cond" for the binary op.
	(cp_parser_transaction_expression): Issue the tm-not-enabled error
	at the location of the __transaction_foo token, rather than at
	input_location.
	* semantics.c (finish_parenthesized_expr): Convert return type and
	param to cp_expr.  Preserve location.
	(perform_koenig_lookup): Likewise for return type
	and param.
	(finish_increment_expr): Likewise.  Generate suitable locations.
	(finish_unary_op_expr): Likewise for return type and local "result".
	Generate suitable locations.
	(finish_id_expression): Convert return type to cp_expr and use
	cp_expr ctor to preserve location information.
	* typeck.c (build_class_member_access_expr): Convert param to
	cp_expr.
	(finish_class_member_access_expr): Likewise.
	(cp_build_binary_op): Convert a build2 to a build2_loc.
	(build_x_unary_op): Convert param from tree to cp_expr.
	(build_nop): Preserve the location of EXPR.
	(build_c_cast): Provide an overloaded variant that takes a cp_expr
	and returns a cp_expr.
	(build_x_modify_expr): Convert return type from tree to cp_expr.

gcc/testsuite/ChangeLog:
	* g++.dg/cpp0x/nsdmi-template14.C: Move dg-error directive.
	* g++.dg/gomp/loop-1.C: Update dg-error locations.
	* g++.dg/plugin/diagnostic-test-expressions-1.C: New file, adapted
	from gcc.dg/plugin/diagnostic-test-expressions-1.c.
	* g++.dg/plugin/plugin.exp (plugin_test_list): Add the above.
	* g++.dg/template/crash55.C: Update dg-error directives.
	* g++.dg/template/pseudodtor3.C: Update column numbers in dg-error
	directives.
	* g++.dg/template/pr64100.C: Update location of dg-error
	directive.
	* g++.dg/template/ref3.C: Add XFAIL (PR c++/68699).
	* g++.dg/ubsan/pr63956.C: Update dg directives to reflect
	improved location information.
	* g++.dg/warn/pr35635.C (func3): Update location of a
	dg-warning.
	* g++.dg/warn/Wconversion-real-integer2.C: Update location of
	dg-warning; add a dg-message.
	* obj-c++.dg/plugin/diagnostic-test-expressions-1.mm: New file,
	based on objc.dg/plugin/diagnostic-test-expressions-1.m.
	* obj-c++.dg/plugin/plugin.exp: New file, based on
	objc.dg/plugin/plugin.exp.

From-SVN: r231293

1 files changed, 38 insertions, 15 deletions

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 3bb6184..82f7d3a 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -1672,8 +1672,8 @@ force_paren_expr (tree expr)
 
 /* Finish a parenthesized expression EXPR.  */
 
-tree
-finish_parenthesized_expr (tree expr)
+cp_expr
+finish_parenthesized_expr (cp_expr expr)
 {
   if (EXPR_P (expr))
     /* This inhibits warnings in c_common_truthvalue_conversion.  */
@@ -1688,7 +1688,7 @@ finish_parenthesized_expr (tree expr)
   if (TREE_CODE (expr) == STRING_CST)
     PAREN_STRING_LITERAL_P (expr) = 1;
 
-  expr = force_paren_expr (expr);
+  expr = cp_expr (force_paren_expr (expr), expr.get_location ());
 
   return expr;
 }
@@ -2164,8 +2164,8 @@ empty_expr_stmt_p (tree expr_stmt)
    the function (or functions) to call; ARGS are the arguments to the
    call.  Returns the functions to be considered by overload resolution.  */
 
-tree
-perform_koenig_lookup (tree fn, vec<tree, va_gc> *args,
+cp_expr
+perform_koenig_lookup (cp_expr fn, vec<tree, va_gc> *args,
 		       tsubst_flags_t complain)
 {
   tree identifier = NULL_TREE;
@@ -2460,10 +2460,23 @@ finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
    is indicated by CODE, which should be POSTINCREMENT_EXPR or
    POSTDECREMENT_EXPR.)  */
 
-tree
-finish_increment_expr (tree expr, enum tree_code code)
-{
-  return build_x_unary_op (input_location, code, expr, tf_warning_or_error);
+cp_expr
+finish_increment_expr (cp_expr expr, enum tree_code code)
+{
+  /* input_location holds the location of the trailing operator token.
+     Build a location of the form:
+       expr++
+       ~~~~^~
+     with the caret at the operator token, ranging from the start
+     of EXPR to the end of the operator token.  */
+  location_t combined_loc = make_location (input_location,
+					   expr.get_start (),
+					   get_finish (input_location));
+  cp_expr result = build_x_unary_op (combined_loc, code, expr,
+				     tf_warning_or_error);
+  /* TODO: build_x_unary_op doesn't honor the location, so set it here.  */
+  result.set_location (combined_loc);
+  return result;
 }
 
 /* Finish a use of `this'.  Returns an expression for `this'.  */
@@ -2557,11 +2570,21 @@ finish_pseudo_destructor_expr (tree object, tree scope, tree destructor,
 
 /* Finish an expression of the form CODE EXPR.  */
 
-tree
-finish_unary_op_expr (location_t loc, enum tree_code code, tree expr,
+cp_expr
+finish_unary_op_expr (location_t op_loc, enum tree_code code, cp_expr expr,
 		      tsubst_flags_t complain)
 {
-  tree result = build_x_unary_op (loc, code, expr, complain);
+  /* Build a location of the form:
+       ++expr
+       ^~~~~~
+     with the caret at the operator token, ranging from the start
+     of the operator token to the end of EXPR.  */
+  location_t combined_loc = make_location (op_loc,
+					   op_loc, expr.get_finish ());
+  cp_expr result = build_x_unary_op (combined_loc, code, expr, complain);
+  /* TODO: build_x_unary_op doesn't always honor the location.  */
+  result.set_location (combined_loc);
+
   tree result_ovl, expr_ovl;
 
   if (!(complain & tf_warning))
@@ -2581,7 +2604,7 @@ finish_unary_op_expr (location_t loc, enum tree_code code, tree expr,
     result_ovl = cp_fully_fold (result_ovl);
 
   if (CONSTANT_CLASS_P (result_ovl) && TREE_OVERFLOW_P (result_ovl))
-    overflow_warning (input_location, result_ovl);
+    overflow_warning (combined_loc, result_ovl);
 
   return result;
 }
@@ -3324,7 +3347,7 @@ process_outer_var_ref (tree decl, tsubst_flags_t complain)
    the use of "this" explicit.
 
    Upon return, *IDK will be filled in appropriately.  */
-tree
+cp_expr
 finish_id_expression (tree id_expression,
 		      tree decl,
 		      tree scope,
@@ -3669,7 +3692,7 @@ finish_id_expression (tree id_expression,
 	}
     }
 
-  return decl;
+  return cp_expr (decl, location);
 }
 
 /* Implement the __typeof keyword: Return the type of EXPR, suitable for