diagnostics: get rid of *_at_rich_loc in favor of overloading

Adding a fix-it hint currently involves changing e.g.:

  error_at (token->location,
            "unknown type name %qE; did you mean %qs?",
            token->value, hint);
to:

  gcc_rich_location richloc (token->location);
  richloc.add_fixit_replace (hint);
  error_at_rich_loc (&richloc,
                     "unknown type name %qE; did you mean %qs?",
                     token->value, hint);

to make the change from taking a location_t to a rich_location *.

This patch renames the "*_at_rich_loc" diagnostic entrypoints to use
the same function names for rich_location * as for location_t,
via overloading, to simplify the above change to just changing from:

  error_at (token->location,
            "unknown type name %qE; did you mean %qs?",
            token->value, hint);
to:

  gcc_rich_location richloc (token->location);
  richloc.add_fixit_replace (hint);
  error_at (&richloc,
            "unknown type name %qE; did you mean %qs?",
            token->value, hint);

thus saving space (and typing) and usually avoiding the need to reindent
the "error_at" invocation.

With this change, 0 is no longer acceptable as a location_t to these
entrypoints, as e.g.:

../../src/gcc/auto-profile.c:855:37: error: call of overloaded
'inform(int, const char [18])' is ambiguous
       inform (0, "Not expected TAG.");
                                     ^
In file included from ../../src/gcc/auto-profile.c:35:0:
../../src/gcc/diagnostic-core.h:88:13: note: candidate:
'void inform(location_t, const char*, ...)'
 extern void inform (location_t, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3);
             ^~~~~~
../../src/gcc/diagnostic-core.h:89:13: note: candidate:
'void inform(rich_location*, const char*, ...)'
 extern void inform (rich_location *, const char *, ...) ATTRIBUTE_GCC_DIAG(2,3);
             ^~~~~~

Such locations now need to be spelled out as UNKNOWN_LOCATION,
rather than 0.

I considered making the API take a rich_location & rather than a
rich_location *, but doing so would mean replacing
  diagnostic_set_info
and
  diagnostic_set_info_translated
with a constructor for diagnostic_info, which was a more invasive
change.  Maybe in the future.

gcc/ChangeLog:
	* auto-profile.c (autofdo_source_profile::read): Use
	UNKNOWN_LOCATION rather than 0.
	* diagnostic-core.h (warning_at_rich_loc): Rename to...
	(warning_at): ...this overload.
	(warning_at_rich_loc_n): Rename to...
	(warning_n): ...this overload.
	(error_at_rich_loc): Rename to...
	(error_at): ...this overload.
	(pedwarn_at_rich_loc): Rename to...
	(pedwarn): ...this overload.
	(permerror_at_rich_loc): Rename to...
	(permerror): ...this overload.
	(inform_at_rich_loc): Rename to...
	(inform): ...this overload.
	* diagnostic.c: (diagnostic_n_impl): Delete location_t-based decl.
	(diagnostic_n_impl_richloc): Rename to...
	(diagnostic_n_impl): ...this rich_location *-based decl.
	(inform_at_rich_loc): Rename to...
	(inform): ...this, and add an assertion.
	(inform_n): Update for removal of location_t-based diagnostic_n_impl.
	(warning_at_rich_loc): Rename to...
	(warning_at): ...this, and add an assertion.
	(warning_at_rich_loc_n): Rename to...
	(warning_n): ...this, and add an assertion.
	(warning_n): Update location_t-based implementation for removal of
	location_t-based diagnostic_n_impl.
	(pedwarn_at_rich_loc): Rename to...
	(pedwarn): ...this, and add an assertion.
	(permerror_at_rich_loc): Rename to...
	(permerror): ...this, and add an assertion.
	(error_n): Update for removal of location_t-based diagnostic_n_impl.
	(error_at_rich_loc): Rename to...
	(error_at): ...this, and add an assertion.
	* gcc.c (do_spec_1): Use UNKNOWN_LOCATION rather than 0.
	(driver::do_spec_on_infiles): Likewise.
	* substring-locations.c (format_warning_va): Update for renaming
	of inform_at_rich_loc.

gcc/c-family/ChangeLog:
	* c-common.c (binary_op_error): Update for renaming of
	error_at_rich_loc.
	(c_parse_error): Likewise.
	* c-warn.c (warn_logical_not_parentheses): Likewise for
	renaming of inform_at_rich_loc.
	(warn_for_restrict): Likewise for renaming of
	warning_at_rich_loc_n.

gcc/c/ChangeLog:
	* c-decl.c (implicit_decl_warning): Update for renaming of
	pedwarn_at_rich_loc and warning_at_rich_loc.
	(implicitly_declare): Likewise for renaming of inform_at_rich_loc.
	(undeclared_variable): Likewise for renaming of error_at_rich_loc.
	* c-parser.c (c_parser_declaration_or_fndef): Likewise.
	(c_parser_struct_or_union_specifier): Likewise for renaming of
	pedwarn_at_rich_loc.
	(c_parser_parameter_declaration): Likewise for renaming of
	error_at_rich_loc.
	* c-typeck.c (build_component_ref): Likewise.
	(build_unary_op): Likewise for renaming of inform_at_rich_loc.
	(pop_init_level): Likewise for renaming of warning_at_rich_loc.
	(set_init_label): Likewise for renaming of error_at_rich_loc.

gcc/cp/ChangeLog:
	* class.c (explain_non_literal_class): Use UNKNOWN_LOCATION rather
	than 0.
	* name-lookup.c (suggest_alternatives_for): Update for renaming of
	inform_at_rich_loc.
	(maybe_suggest_missing_header): Likewise.
	(suggest_alternative_in_explicit_scope): Likewise.
	* parser.c (cp_parser_diagnose_invalid_type_name): Likewise for
	renaming of error_at_rich_loc.
	(cp_parser_string_literal): Likewise.
	(cp_parser_nested_name_specifier_opt): Likewise.
	(cp_parser_cast_expression): Likewise for renaming of
	warning_at_rich_loc.
	(cp_parser_decl_specifier_seq): Likewise for renaming of
	error_at_rich_loc and warning_at_rich_loc.
	(cp_parser_elaborated_type_specifier): Likewise for renaming of
	pedwarn_at_rich_loc.
	(cp_parser_cv_qualifier_seq_opt): Likewise for renaming of
	error_at_rich_loc.
	(cp_parser_virt_specifier_seq_opt): Likewise.
	(cp_parser_class_specifier_1): Likewise.
	(cp_parser_class_head): Likewise.
	(cp_parser_member_declaration): Likewise for renaming of
	pedwarn_at_rich_loc, warning_at_rich_loc, and error_at_rich_loc.
	(cp_parser_enclosed_template_argument_list): Likewise for renaming
	of error_at_rich_loc.
	(set_and_check_decl_spec_loc): Likewise.
	* pt.c (listify): Likewise.
	* rtti.c (typeid_ok_p): Likewise.
	* semantics.c (process_outer_var_ref): Use UNKNOWN_LOCATION rather
	than 0.
	* typeck.c (access_failure_info::maybe_suggest_accessor): Update
	for renaming of inform_at_rich_loc.
	(finish_class_member_access_expr): Likewise for renaming of
	error_at_rich_loc.

gcc/objc/ChangeLog:
	* objc-gnu-runtime-abi-01.c (objc_gnu_runtime_abi_01_init): Use
	UNKNOWN_LOCATION rather than 0.

gcc/testsuite/ChangeLog:
	* gcc.dg/plugin/diagnostic_plugin_show_trees.c (show_tree): Update
	for renaming of error_at_rich_loc and inform_at_rich_loc.
	* gcc.dg/plugin/diagnostic_plugin_test_show_locus.c
	(test_show_locus): Likewise for renaming of warning_at_rich_loc.

libcpp/ChangeLog:
	* directives.c (_cpp_handle_directive): Update for renaming of
	cpp_error_at_richloc to cpp_error_at.
	* errors.c (cpp_diagnostic_at_richloc): Rename to...
	(cpp_diagnostic_at): ...this, dropping the location_t-based
	implementation.
	(cpp_diagnostic): Update for removal of location_t-based
	cpp_diagnostic_at.
	(cpp_error_at): Likewise.
	(cpp_error_at_richloc): Rename to...
	(cpp_error_at): ...this, and update for renaming of
	cpp_diagnostic_at_richloc.
	* include/cpplib.h (cpp_error_at_richloc): Rename to...
	(cpp_error_at): ...this.

From-SVN: r254280

8 files changed, 108 insertions, 68 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 191fa11..4b92622 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,40 @@
+2017-10-31  David Malcolm  <dmalcolm@redhat.com>
+
+	* class.c (explain_non_literal_class): Use UNKNOWN_LOCATION rather
+	than 0.
+	* name-lookup.c (suggest_alternatives_for): Update for renaming of
+	inform_at_rich_loc.
+	(maybe_suggest_missing_header): Likewise.
+	(suggest_alternative_in_explicit_scope): Likewise.
+	* parser.c (cp_parser_diagnose_invalid_type_name): Likewise for
+	renaming of error_at_rich_loc.
+	(cp_parser_string_literal): Likewise.
+	(cp_parser_nested_name_specifier_opt): Likewise.
+	(cp_parser_cast_expression): Likewise for renaming of
+	warning_at_rich_loc.
+	(cp_parser_decl_specifier_seq): Likewise for renaming of
+	error_at_rich_loc and warning_at_rich_loc.
+	(cp_parser_elaborated_type_specifier): Likewise for renaming of
+	pedwarn_at_rich_loc.
+	(cp_parser_cv_qualifier_seq_opt): Likewise for renaming of
+	error_at_rich_loc.
+	(cp_parser_virt_specifier_seq_opt): Likewise.
+	(cp_parser_class_specifier_1): Likewise.
+	(cp_parser_class_head): Likewise.
+	(cp_parser_member_declaration): Likewise for renaming of
+	pedwarn_at_rich_loc, warning_at_rich_loc, and error_at_rich_loc.
+	(cp_parser_enclosed_template_argument_list): Likewise for renaming
+	of error_at_rich_loc.
+	(set_and_check_decl_spec_loc): Likewise.
+	* pt.c (listify): Likewise.
+	* rtti.c (typeid_ok_p): Likewise.
+	* semantics.c (process_outer_var_ref): Use UNKNOWN_LOCATION rather
+	than 0.
+	* typeck.c (access_failure_info::maybe_suggest_accessor): Update
+	for renaming of inform_at_rich_loc.
+	(finish_class_member_access_expr): Likewise for renaming of
+	error_at_rich_loc.
+
 2017-10-31  Nathan Sidwell  <nathan@acm.org>
 
 	* cp-tree.h (struct operator_name_info_t): Rename to ...
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index 9755f18..98e62c6 100644
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -5394,18 +5394,20 @@ explain_non_literal_class (tree t)
     /* Already explained.  */
     return;
 
-  inform (0, "%q+T is not literal because:", t);
+  inform (UNKNOWN_LOCATION, "%q+T is not literal because:", t);
   if (cxx_dialect < cxx17 && LAMBDA_TYPE_P (t))
-    inform (0, "  %qT is a closure type, which is only literal in "
+    inform (UNKNOWN_LOCATION,
+	    "  %qT is a closure type, which is only literal in "
 	    "C++17 and later", t);
   else if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t))
-    inform (0, "  %q+T has a non-trivial destructor", t);
+    inform (UNKNOWN_LOCATION, "  %q+T has a non-trivial destructor", t);
   else if (CLASSTYPE_NON_AGGREGATE (t)
 	   && !TYPE_HAS_TRIVIAL_DFLT (t)
 	   && !LAMBDA_TYPE_P (t)
 	   && !TYPE_HAS_CONSTEXPR_CTOR (t))
     {
-      inform (0, "  %q+T is not an aggregate, does not have a trivial "
+      inform (UNKNOWN_LOCATION,
+	      "  %q+T is not an aggregate, does not have a trivial "
 	      "default constructor, and has no constexpr constructor that "
 	      "is not a copy or move constructor", t);
       if (type_has_non_user_provided_default_constructor (t))
@@ -5437,7 +5439,8 @@ explain_non_literal_class (tree t)
 	  tree basetype = TREE_TYPE (base_binfo);
 	  if (!CLASSTYPE_LITERAL_P (basetype))
 	    {
-	      inform (0, "  base class %qT of %q+T is non-literal",
+	      inform (UNKNOWN_LOCATION,
+		      "  base class %qT of %q+T is non-literal",
 		      basetype, t);
 	      explain_non_literal_class (basetype);
 	      return;
diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c
index 1b35390..b4976d8 100644
--- a/gcc/cp/name-lookup.c
+++ b/gcc/cp/name-lookup.c
@@ -5377,7 +5377,7 @@ suggest_alternatives_for (location_t location, tree name,
       gcc_rich_location richloc (location);
 
       richloc.add_fixit_replace (fuzzy);
-      inform_at_rich_loc (&richloc, "suggested alternative: %qs", fuzzy);
+      inform (&richloc, "suggested alternative: %qs", fuzzy);
     }
 }
 
@@ -5485,10 +5485,10 @@ maybe_suggest_missing_header (location_t location, tree name, tree scope)
 
   gcc_rich_location richloc (location);
   maybe_add_include_fixit (&richloc, header_hint);
-  inform_at_rich_loc (&richloc,
-		      "%<std::%s%> is defined in header %qs;"
-		      " did you forget to %<#include %s%>?",
-		      name_str, header_hint, header_hint);
+  inform (&richloc,
+	  "%<std::%s%> is defined in header %qs;"
+	  " did you forget to %<#include %s%>?",
+	  name_str, header_hint, header_hint);
   return true;
 }
 
@@ -5518,8 +5518,8 @@ suggest_alternative_in_explicit_scope (location_t location, tree name,
     {
       gcc_rich_location richloc (location);
       richloc.add_fixit_replace (fuzzy_name);
-      inform_at_rich_loc (&richloc, "suggested alternative: %qs",
-			  fuzzy_name);
+      inform (&richloc, "suggested alternative: %qs",
+	      fuzzy_name);
       return true;
     }
 
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index bcaefde..77b9637 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -3294,9 +3294,9 @@ cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree id,
 	{
 	  gcc_rich_location richloc (location);
 	  richloc.add_fixit_replace (suggestion);
-	  error_at_rich_loc (&richloc,
-			     "%qE does not name a type; did you mean %qs?",
-			     id, suggestion);
+	  error_at (&richloc,
+		    "%qE does not name a type; did you mean %qs?",
+		    id, suggestion);
 	}
       else
 	error_at (location, "%qE does not name a type", id);
@@ -4107,9 +4107,9 @@ cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
 		{
 		  rich_location rich_loc (line_table, tok->location);
 		  rich_loc.add_range (last_tok_loc, false);
-		  error_at_rich_loc (&rich_loc,
-				     "unsupported non-standard concatenation "
-				     "of string literals");
+		  error_at (&rich_loc,
+			    "unsupported non-standard concatenation "
+			    "of string literals");
 		}
 	    }
 
@@ -6163,9 +6163,9 @@ cp_parser_nested_name_specifier_opt (cp_parser *parser,
 	    {
 	      gcc_rich_location richloc (token->location);
 	      richloc.add_fixit_replace ("::");
-	      error_at_rich_loc (&richloc,
-				 "found %<:%> in nested-name-specifier, "
-				 "expected %<::%>");
+	      error_at (&richloc,
+			"found %<:%> in nested-name-specifier, "
+			"expected %<::%>");
 	      token->type = CPP_SCOPE;
 	    }
 
@@ -9097,8 +9097,8 @@ cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p,
 		  gcc_rich_location rich_loc (input_location);
 		  maybe_add_cast_fixit (&rich_loc, open_paren_loc, close_paren_loc,
 					expr, type);
-		  warning_at_rich_loc (&rich_loc, OPT_Wold_style_cast,
-				       "use of old-style cast to %q#T", type);
+		  warning_at (&rich_loc, OPT_Wold_style_cast,
+			      "use of old-style cast to %q#T", type);
 		}
 
 	      /* Only type conversions to integral or enumeration types
@@ -13549,7 +13549,7 @@ cp_parser_decl_specifier_seq (cp_parser* parser,
 	    {
 	      gcc_rich_location richloc (token->location);
 	      richloc.add_fixit_remove ();
-	      error_at_rich_loc (&richloc, "%<friend%> used outside of class");
+	      error_at (&richloc, "%<friend%> used outside of class");
 	      cp_lexer_purge_token (parser->lexer);
 	    }
 	  else
@@ -13615,9 +13615,9 @@ cp_parser_decl_specifier_seq (cp_parser* parser,
 		 we're complaining about C++0x compatibility.  */
 	      gcc_rich_location richloc (token->location);
 	      richloc.add_fixit_remove ();
-	      warning_at_rich_loc (&richloc, OPT_Wc__11_compat,
-				   "%<auto%> changes meaning in C++11; "
-				   "please remove it");
+	      warning_at (&richloc, OPT_Wc__11_compat,
+			  "%<auto%> changes meaning in C++11; "
+			  "please remove it");
 
               /* Set the storage class anyway.  */
               cp_parser_set_storage_class (parser, decl_specs, RID_AUTO,
@@ -17661,9 +17661,9 @@ cp_parser_elaborated_type_specifier (cp_parser* parser,
 	  gcc_rich_location richloc (token->location);
 	  richloc.add_range (input_location, false);
 	  richloc.add_fixit_remove ();
-	  pedwarn_at_rich_loc (&richloc, 0, "elaborated-type-specifier for "
-			       "a scoped enum must not use the %qD keyword",
-			       token->u.value);
+	  pedwarn (&richloc, 0, "elaborated-type-specifier for "
+		   "a scoped enum must not use the %qD keyword",
+		   token->u.value);
 	  /* Consume the `struct' or `class' and parse it anyway.  */
 	  cp_lexer_consume_token (parser->lexer);
 	}
@@ -20659,7 +20659,7 @@ cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
 	{
 	  gcc_rich_location richloc (token->location);
 	  richloc.add_fixit_remove ();
-	  error_at_rich_loc (&richloc, "duplicate cv-qualifier");
+	  error_at (&richloc, "duplicate cv-qualifier");
 	  cp_lexer_purge_token (parser->lexer);
 	}
       else
@@ -20808,7 +20808,7 @@ cp_parser_virt_specifier_seq_opt (cp_parser* parser)
 	{
 	  gcc_rich_location richloc (token->location);
 	  richloc.add_fixit_remove ();
-	  error_at_rich_loc (&richloc, "duplicate virt-specifier");
+	  error_at (&richloc, "duplicate virt-specifier");
 	  cp_lexer_purge_token (parser->lexer);
 	}
       else
@@ -22606,14 +22606,14 @@ cp_parser_class_specifier_1 (cp_parser* parser)
 	  richloc.add_fixit_insert_before (next_loc, ";");
 
 	if (CLASSTYPE_DECLARED_CLASS (type))
-	  error_at_rich_loc (&richloc,
-			     "expected %<;%> after class definition");
+	  error_at (&richloc,
+		    "expected %<;%> after class definition");
 	else if (TREE_CODE (type) == RECORD_TYPE)
-	  error_at_rich_loc (&richloc,
-			     "expected %<;%> after struct definition");
+	  error_at (&richloc,
+		    "expected %<;%> after struct definition");
 	else if (TREE_CODE (type) == UNION_TYPE)
-	  error_at_rich_loc (&richloc,
-			     "expected %<;%> after union definition");
+	  error_at (&richloc,
+		    "expected %<;%> after union definition");
 	else
 	  gcc_unreachable ();
 
@@ -23060,9 +23060,9 @@ cp_parser_class_head (cp_parser* parser,
       rich_location richloc (line_table, reported_loc);
       richloc.add_fixit_insert_before (class_head_start_location,
                                        "template <> ");
-      error_at_rich_loc
-        (&richloc,
-         "an explicit specialization must be preceded by %<template <>%>");
+      error_at (&richloc,
+		"an explicit specialization must be preceded by"
+		" %<template <>%>");
       invalid_explicit_specialization_p = true;
       /* Take the same action that would have been taken by
 	 cp_parser_explicit_specialization.  */
@@ -23530,7 +23530,7 @@ cp_parser_member_declaration (cp_parser* parser)
 	    {
 	      gcc_rich_location richloc (token->location);
 	      richloc.add_fixit_remove ();
-	      pedwarn_at_rich_loc (&richloc, OPT_Wpedantic, "extra %<;%>");
+	      pedwarn (&richloc, OPT_Wpedantic, "extra %<;%>");
 	    }
 	}
       else
@@ -23873,9 +23873,9 @@ cp_parser_member_declaration (cp_parser* parser)
 			= cp_lexer_consume_token (parser->lexer)->location;
 		      gcc_rich_location richloc (semicolon_loc);
 		      richloc.add_fixit_remove ();
-		      warning_at_rich_loc (&richloc, OPT_Wextra_semi,
-					   "extra %<;%> after in-class "
-					   "function definition");
+		      warning_at (&richloc, OPT_Wextra_semi,
+				  "extra %<;%> after in-class "
+				  "function definition");
 		    }
 		  goto out;
 		}
@@ -23918,8 +23918,8 @@ cp_parser_member_declaration (cp_parser* parser)
 		  cp_token *token = cp_lexer_previous_token (parser->lexer);
 		  gcc_rich_location richloc (token->location);
 		  richloc.add_fixit_remove ();
-		  error_at_rich_loc (&richloc, "stray %<,%> at end of "
-				     "member declaration");
+		  error_at (&richloc, "stray %<,%> at end of "
+			    "member declaration");
 		}
 	    }
 	  /* If the next token isn't a `;', then we have a parse error.  */
@@ -23932,8 +23932,8 @@ cp_parser_member_declaration (cp_parser* parser)
 	      cp_token *token = cp_lexer_previous_token (parser->lexer);
 	      gcc_rich_location richloc (token->location);
 	      richloc.add_fixit_insert_after (";");
-	      error_at_rich_loc (&richloc, "expected %<;%> at end of "
-				 "member declaration");
+	      error_at (&richloc, "expected %<;%> at end of "
+			"member declaration");
 
 	      /* Assume that the user meant to provide a semicolon.  If
 		 we were to cp_parser_skip_to_end_of_statement, we might
@@ -27544,8 +27544,8 @@ cp_parser_enclosed_template_argument_list (cp_parser* parser)
 	  cp_token *token = cp_lexer_peek_token (parser->lexer);
 	  gcc_rich_location richloc (token->location);
 	  richloc.add_fixit_replace ("> >");
-	  error_at_rich_loc (&richloc, "%<>>%> should be %<> >%> "
-			     "within a nested template argument list");
+	  error_at (&richloc, "%<>>%> should be %<> >%> "
+		    "within a nested template argument list");
 
 	  token->type = CPP_GREATER;
 	}
@@ -28174,7 +28174,7 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
 	    {
 	      gcc_rich_location richloc (location);
 	      richloc.add_fixit_remove ();
-	      error_at_rich_loc (&richloc, "duplicate %qD", token->u.value);
+	      error_at (&richloc, "duplicate %qD", token->u.value);
 	    }
 	}
       else
@@ -28198,7 +28198,7 @@ set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
 	  };
 	  gcc_rich_location richloc (location);
 	  richloc.add_fixit_remove ();
-	  error_at_rich_loc (&richloc, "duplicate %qs", decl_spec_names[ds]);
+	  error_at (&richloc, "duplicate %qs", decl_spec_names[ds]);
 	}
     }
 }
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 326be33..f525d22 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -25130,9 +25130,9 @@ listify (tree arg)
     {    
       gcc_rich_location richloc (input_location);
       maybe_add_include_fixit (&richloc, "<initializer_list>");
-      error_at_rich_loc (&richloc,
-                         "deducing from brace-enclosed initializer list"
-                         " requires #include <initializer_list>");
+      error_at (&richloc,
+		"deducing from brace-enclosed initializer list"
+		" requires #include <initializer_list>");
 
       return error_mark_node;
     }
diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c
index 5b2326c..10ecbfd 100644
--- a/gcc/cp/rtti.c
+++ b/gcc/cp/rtti.c
@@ -319,9 +319,9 @@ typeid_ok_p (void)
     {
       gcc_rich_location richloc (input_location);
       maybe_add_include_fixit (&richloc, "<typeinfo>");
-      error_at_rich_loc (&richloc,
-			 "must %<#include <typeinfo>%> before using"
-			 " %<typeid%>");
+      error_at (&richloc,
+		"must %<#include <typeinfo>%> before using"
+		" %<typeid%>");
 
       return false;
     }
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index b513c4d..664952e 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -3399,7 +3399,7 @@ process_outer_var_ref (tree decl, tsubst_flags_t complain, bool force_use)
 	    inform (location_of (closure),
 		    "the lambda has no capture-default");
 	  else if (TYPE_CLASS_SCOPE_P (closure))
-	    inform (0, "lambda in local class %q+T cannot "
+	    inform (UNKNOWN_LOCATION, "lambda in local class %q+T cannot "
 		    "capture variables from the enclosing context",
 		    TYPE_CONTEXT (closure));
 	  inform (DECL_SOURCE_LOCATION (decl), "%q#D declared here", decl);
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 38fd158..285d8d2 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -2677,8 +2677,8 @@ access_failure_info::maybe_suggest_accessor (bool const_p) const
   pretty_printer pp;
   pp_printf (&pp, "%s()", IDENTIFIER_POINTER (DECL_NAME (accessor)));
   richloc.add_fixit_replace (pp_formatted_text (&pp));
-  inform_at_rich_loc (&richloc, "field %q#D can be accessed via %q#D",
-		      m_field_decl, accessor);
+  inform (&richloc, "field %q#D can be accessed via %q#D",
+	  m_field_decl, accessor);
 }
 
 /* This function is called by the parser to process a class member
@@ -2883,12 +2883,12 @@ finish_class_member_access_expr (cp_expr object, tree name, bool template_p,
 		      gcc_rich_location rich_loc (bogus_component_loc);
 		      rich_loc.add_fixit_misspelled_id (bogus_component_loc,
 							guessed_id);
-		      error_at_rich_loc
-			(&rich_loc,
-			 "%q#T has no member named %qE; did you mean %qE?",
-			 TREE_CODE (access_path) == TREE_BINFO
-			 ? TREE_TYPE (access_path) : object_type, name,
-			 guessed_id);
+		      error_at (&rich_loc,
+				"%q#T has no member named %qE;"
+				" did you mean %qE?",
+				TREE_CODE (access_path) == TREE_BINFO
+				? TREE_TYPE (access_path) : object_type,
+				name, guessed_id);
 		    }
 		  else
 		    error ("%q#T has no member named %qE",