Attempt to significantly reduce warning count by modifying error message format

1 files changed, 286 insertions, 275 deletions

diff --git a/gcc/rust/parse/rust-parse-impl.h b/gcc/rust/parse/rust-parse-impl.h
index 72957df..51ff16e 100644
--- a/gcc/rust/parse/rust-parse-impl.h
+++ b/gcc/rust/parse/rust-parse-impl.h
@@ -238,7 +238,7 @@ Parser<ManagedTokenSource>::skip_generics_right_angle ()
       }
     default:
       rust_error_at (tok->get_locus (),
-		     "expected '>' at end of generic argument - found '%s'",
+		     "expected %<>%> at end of generic argument - found %<%s%>",
 		     tok->get_token_description ());
       return false;
     }
@@ -583,8 +583,7 @@ Parser<ManagedTokenSource>::parse_simple_path ()
 	{
 	  fprintf (stderr,
 		   "when parsing simple path, somehow empty path segment was "
-		   "not filtered out. Path "
-		   "begins with '%s' \n",
+		   "not filtered out. Path begins with '%s' \n",
 		   segments.at (0).as_string ().c_str ());
 	}
     }
@@ -629,8 +628,8 @@ Parser<ManagedTokenSource>::parse_simple_path_segment ()
       gcc_fallthrough ();
     default:
       // do nothing but inactivates warning from gcc when compiling
-      // could put the rust_error_at thing here but fallthrough (from failing
-      // $crate condition) isn't completely obvious if it is.
+      /* could put the rust_error_at thing here but fallthrough (from failing
+       * $crate condition) isn't completely obvious if it is. */
 
       // test prevent error
       return AST::SimplePathSegment::create_error ();
@@ -722,7 +721,7 @@ Parser<ManagedTokenSource>::parse_attr_input ()
 	  {
 	    rust_error_at (
 	      t->get_locus (),
-	      "unknown token '%s' in attribute body - literal expected",
+	      "unknown token %<%s%> in attribute body - literal expected",
 	      t->get_token_description ());
 	    skip_after_end_attribute ();
 	    return nullptr;
@@ -771,7 +770,7 @@ Parser<ManagedTokenSource>::parse_attr_input ()
       return nullptr;
     default:
       rust_error_at (t->get_locus (),
-		     "unknown token '%s' in attribute body - attribute input "
+		     "unknown token %<%s%> in attribute body - attribute input "
 		     "or none expected",
 		     t->get_token_description ());
       skip_after_end_attribute ();
@@ -838,7 +837,7 @@ Parser<ManagedTokenSource>::parse_delim_token_tree ()
       break;
     default:
       rust_error_at (t->get_locus (),
-		     "unexpected token '%s' - expecting delimiters (for a "
+		     "unexpected token %<%s%> - expecting delimiters (for a "
 		     "delimited token tree)",
 		     t->get_token_description ());
       return AST::DelimTokenTree::create_empty ();
@@ -858,7 +857,7 @@ Parser<ManagedTokenSource>::parse_delim_token_tree ()
 	  // TODO: is this error handling appropriate?
 	  rust_error_at (
 	    t->get_locus (),
-	    "failed to parse token tree in delimited token tree - found '%s'",
+	    "failed to parse token tree in delimited token tree - found %<%s%>",
 	    t->get_token_description ());
 	  return AST::DelimTokenTree::create_empty ();
 	}
@@ -892,13 +891,13 @@ Parser<ManagedTokenSource>::parse_delim_token_tree ()
   else
     {
       // tokens don't match opening delimiters, so produce error
-      rust_error_at (t->get_locus (),
-		     "unexpected token '%s' - expecting closing delimiter '%s' "
-		     "(for a delimited token tree)",
-		     t->get_token_description (),
-		     (delim_type == AST::PARENS
-			? ")"
-			: (delim_type == AST::SQUARE ? "]" : "}")));
+      rust_error_at (
+	t->get_locus (),
+	"unexpected token %<%s%> - expecting closing delimiter %<%s%> "
+	"(for a delimited token tree)",
+	t->get_token_description (),
+	(delim_type == AST::PARENS ? ")"
+				   : (delim_type == AST::SQUARE ? "]" : "}")));
 
       /* return empty token tree despite possibly parsing valid token tree -
        * TODO is this a good idea? */
@@ -927,11 +926,11 @@ Parser<ManagedTokenSource>::parse_token_tree ()
     case RIGHT_SQUARE:
     case RIGHT_CURLY:
       // error - should not be called when this a token
-      rust_error_at (t->get_locus (),
-		     "unexpected closing delimiter '%s' - token tree requires "
-		     "either paired delimiters "
-		     "or non-delimiter tokens",
-		     t->get_token_description ());
+      rust_error_at (
+	t->get_locus (),
+	"unexpected closing delimiter %<%s%> - token tree requires "
+	"either paired delimiters or non-delimiter tokens",
+	t->get_token_description ());
       lexer.skip_token ();
       return nullptr;
     default:
@@ -983,8 +982,8 @@ Parser<ManagedTokenSource>::parse_item (bool called_from_statement)
   std::vector<AST::Attribute> outer_attrs = parse_outer_attributes ();
 
   // TODO: decide how to deal with VisItem vs MacroItem dichotomy
-  // best current solution: catch all keywords that would imply a VisItem in a
-  // switch and have MacroItem as a last resort
+  /* best current solution: catch all keywords that would imply a VisItem in a
+   * switch and have MacroItem as a last resort */
 
   const_TokenPtr t = lexer.peek_token ();
 
@@ -1037,8 +1036,8 @@ Parser<ManagedTokenSource>::parse_item (bool called_from_statement)
       else if (lexer.peek_token (1)->get_id () == SCOPE_RESOLUTION
 	       || lexer.peek_token (1)->get_id () == EXCLAM)
 	{
-	  // path (probably) or macro invocation, so probably a macro invocation
-	  // semi
+	  /* path (probably) or macro invocation, so probably a macro invocation
+	   * semi */
 	  return parse_macro_item (std::move (outer_attrs));
 	}
       gcc_fallthrough ();
@@ -1046,7 +1045,8 @@ Parser<ManagedTokenSource>::parse_item (bool called_from_statement)
     default:
       // otherwise unrecognised
       // return parse_macro_item(std::move(outer_attrs));
-      rust_error_at (t->get_locus (), "unrecognised token '%s' for start of %s",
+      rust_error_at (t->get_locus (),
+		     "unrecognised token %<%s%> for start of %s",
 		     t->get_token_description (),
 		     called_from_statement ? "statement" : "item");
       // skip somewhere?
@@ -1066,8 +1066,8 @@ Parser<ManagedTokenSource>::parse_outer_attributes ()
     {
       AST::Attribute outer_attr = parse_outer_attribute ();
 
-      // Ensure only valid outer attributes are added to the outer_attributes
-      // list
+      /* Ensure only valid outer attributes are added to the outer_attributes
+       * list */
       if (!outer_attr.is_empty ())
 	{
 	  outer_attributes.push_back (std::move (outer_attr));
@@ -1104,10 +1104,10 @@ Parser<ManagedTokenSource>::parse_outer_attribute ()
       if (id == EXCLAM)
 	{
 	  // this is inner attribute syntax, so throw error
-	  rust_error_at (lexer.peek_token ()->get_locus (),
-			 "token '!' found, indicating inner attribute "
-			 "definition. Inner attributes are not "
-			 "possible at this location.");
+	  rust_error_at (
+	    lexer.peek_token ()->get_locus (),
+	    "token %<!%> found, indicating inner attribute definition. Inner "
+	    "attributes are not possible at this location");
 	} // TODO: are there any cases where this wouldn't be an error?
       return AST::Attribute::create_empty ();
     }
@@ -1166,7 +1166,7 @@ Parser<ManagedTokenSource>::parse_vis_item (
 	    default:
 	      rust_error_at (
 		t->get_locus (),
-		"unexpected token '%s' in some sort of extern production",
+		"unexpected token %<%s%> in some sort of extern production",
 		t->get_token_description ());
 	      lexer.skip_token (2); // TODO: is this right thing to do?
 	      return nullptr;
@@ -1174,7 +1174,7 @@ Parser<ManagedTokenSource>::parse_vis_item (
 	default:
 	  rust_error_at (
 	    t->get_locus (),
-	    "unexpected token '%s' in some sort of extern production",
+	    "unexpected token %<%s%> in some sort of extern production",
 	    t->get_token_description ());
 	  lexer.skip_token (1); // TODO: is this right thing to do?
 	  return nullptr;
@@ -1218,7 +1218,7 @@ Parser<ManagedTokenSource>::parse_vis_item (
 	default:
 	  rust_error_at (
 	    t->get_locus (),
-	    "unexpected token '%s' in some sort of const production",
+	    "unexpected token %<%s%> in some sort of const production",
 	    t->get_token_description ());
 	  lexer.skip_token (1); // TODO: is this right thing to do?
 	  return nullptr;
@@ -1245,7 +1245,7 @@ Parser<ManagedTokenSource>::parse_vis_item (
 	default:
 	  rust_error_at (
 	    t->get_locus (),
-	    "unexpected token '%s' in some sort of unsafe production",
+	    "unexpected token %<%s%> in some sort of unsafe production",
 	    t->get_token_description ());
 	  lexer.skip_token (1); // TODO: is this right thing to do?
 	  return nullptr;
@@ -1290,8 +1290,7 @@ Parser<ManagedTokenSource>::parse_macro_item (
 	{
 	  fprintf (stderr,
 		   "just add to last error: token is not macro_rules and is "
-		   "not an identifier either "
-		   "- it is '%s'",
+		   "not an identifier either - it is '%s'",
 		   t->get_token_description ());
 	}
 
@@ -1311,7 +1310,7 @@ Parser<ManagedTokenSource>::parse_macro_rules_def (
     {
       rust_error_at (
 	t->get_locus (),
-	"macro rules definition does not start with 'macro_rules'");
+	"macro rules definition does not start with %<macro_rules%>");
       // skip after somewhere?
       return nullptr;
     }
@@ -1353,7 +1352,7 @@ Parser<ManagedTokenSource>::parse_macro_rules_def (
       break;
     default:
       rust_error_at (t->get_locus (),
-		     "unexpected token '%s' - expecting delimiters (for a "
+		     "unexpected token %<%s%> - expecting delimiters (for a "
 		     "macro rules definition)",
 		     t->get_token_description ());
       return nullptr;
@@ -1442,14 +1441,13 @@ Parser<ManagedTokenSource>::parse_macro_rules_def (
   else
     {
       // tokens don't match opening delimiters, so produce error
-      rust_error_at (t->get_locus (),
-		     "unexpected token '%s' - expecting closing delimiter '%s' "
-		     "(for a macro rules "
-		     "definition)",
-		     t->get_token_description (),
-		     (delim_type == AST::PARENS
-			? ")"
-			: (delim_type == AST::SQUARE ? "]" : "}")));
+      rust_error_at (
+	t->get_locus (),
+	"unexpected token %<%s%> - expecting closing delimiter %<%s%> "
+	"(for a macro rules definition)",
+	t->get_token_description (),
+	(delim_type == AST::PARENS ? ")"
+				   : (delim_type == AST::SQUARE ? "]" : "}")));
 
       /* return empty macro definiton despite possibly parsing mostly valid one
        * - TODO is this a good idea? */
@@ -1490,7 +1488,7 @@ Parser<ManagedTokenSource>::parse_macro_invocation_semi (
       break;
     default:
       rust_error_at (t->get_locus (),
-		     "unexpected token '%s' - expecting delimiters (for a "
+		     "unexpected token %<%s%> - expecting delimiters (for a "
 		     "macro invocation semi body)",
 		     t->get_token_description ());
       return nullptr;
@@ -1508,10 +1506,10 @@ Parser<ManagedTokenSource>::parse_macro_invocation_semi (
 
       if (tree == nullptr)
 	{
-	  rust_error_at (
-	    t->get_locus (),
-	    "failed to parse token tree for macro invocation semi - found '%s'",
-	    t->get_token_description ());
+	  rust_error_at (t->get_locus (),
+			 "failed to parse token tree for macro invocation semi "
+			 "- found %<%s%>",
+			 t->get_token_description ());
 	  return nullptr;
 	}
 
@@ -1555,14 +1553,13 @@ Parser<ManagedTokenSource>::parse_macro_invocation_semi (
   else
     {
       // tokens don't match opening delimiters, so produce error
-      rust_error_at (t->get_locus (),
-		     "unexpected token '%s' - expecting closing delimiter '%s' "
-		     "(for a macro invocation "
-		     "semi)",
-		     t->get_token_description (),
-		     (delim_type == AST::PARENS
-			? ")"
-			: (delim_type == AST::SQUARE ? "]" : "}")));
+      rust_error_at (
+	t->get_locus (),
+	"unexpected token %<%s%> - expecting closing delimiter %<%s%> "
+	"(for a macro invocation semi)",
+	t->get_token_description (),
+	(delim_type == AST::PARENS ? ")"
+				   : (delim_type == AST::SQUARE ? "]" : "}")));
 
       /* return empty macro invocation despite possibly parsing mostly valid one
        * - TODO is this a good idea? */
@@ -1612,9 +1609,7 @@ Parser<ManagedTokenSource>::parse_macro_rule ()
   AST::MacroMatcher matcher = parse_macro_matcher ();
 
   if (matcher.is_error ())
-    {
-      return AST::MacroRule::create_error ();
-    }
+    return AST::MacroRule::create_error ();
 
   if (!skip_token (MATCH_ARROW))
     {
@@ -1655,7 +1650,7 @@ Parser<ManagedTokenSource>::parse_macro_matcher ()
     default:
       rust_error_at (
 	t->get_locus (),
-	"unexpected token '%s' - expecting delimiters (for a macro matcher)",
+	"unexpected token %<%s%> - expecting delimiters (for a macro matcher)",
 	t->get_token_description ());
       return AST::MacroMatcher::create_error ();
     }
@@ -1674,7 +1669,7 @@ Parser<ManagedTokenSource>::parse_macro_matcher ()
 	{
 	  rust_error_at (
 	    t->get_locus (),
-	    "failed to parse macro match for macro matcher - found '%s'",
+	    "failed to parse macro match for macro matcher - found %<%s%>",
 	    t->get_token_description ());
 	  return AST::MacroMatcher::create_error ();
 	}
@@ -1699,13 +1694,13 @@ Parser<ManagedTokenSource>::parse_macro_matcher ()
   else
     {
       // tokens don't match opening delimiters, so produce error
-      rust_error_at (t->get_locus (),
-		     "unexpected token '%s' - expecting closing delimiter '%s' "
-		     "(for a macro matcher)",
-		     t->get_token_description (),
-		     (delim_type == AST::PARENS
-			? ")"
-			: (delim_type == AST::SQUARE ? "]" : "}")));
+      rust_error_at (
+	t->get_locus (),
+	"unexpected token %<%s%> - expecting closing delimiter %<%s%> "
+	"(for a macro matcher)",
+	t->get_token_description (),
+	(delim_type == AST::PARENS ? ")"
+				   : (delim_type == AST::SQUARE ? "]" : "}")));
 
       /* return error macro matcher despite possibly parsing mostly correct one?
        * TODO is this the best idea? */
@@ -1749,11 +1744,11 @@ Parser<ManagedTokenSource>::parse_macro_match ()
 	    return parse_macro_match_repetition ();
 	  default:
 	    // error: unrecognised
-	    rust_error_at (t2->get_locus (),
-			   "unrecognised token combination '$%s' at start of "
-			   "macro match - did you "
-			   "mean '$identifier' or '$('?",
-			   t2->get_token_description ());
+	    rust_error_at (
+	      t2->get_locus (),
+	      "unrecognised token combination %<$%s%> at start of "
+	      "macro match - did you mean %<$identifier%> or %<$(%>?",
+	      t2->get_token_description ());
 	    // skip somewhere?
 	    return nullptr;
 	  }
@@ -1763,7 +1758,7 @@ Parser<ManagedTokenSource>::parse_macro_match ()
     case RIGHT_CURLY:
       // not allowed
       rust_error_at (t->get_locus (),
-		     "closing delimiters like '%s' are not allowed at the "
+		     "closing delimiters like %<%s%> are not allowed at the "
 		     "start of a macro match",
 		     t->get_token_description ());
       // skip somewhere?
@@ -1802,9 +1797,10 @@ Parser<ManagedTokenSource>::parse_macro_match_fragment ()
   AST::MacroFragSpec frag = AST::get_frag_spec_from_str (t->get_str ());
   if (frag == AST::INVALID)
     {
-      rust_error_at (t->get_locus (),
-		     "invalid fragment specifier '%s' in fragment macro match",
-		     t->get_str ().c_str ());
+      rust_error_at (
+	t->get_locus (),
+	"invalid fragment specifier %<%s%> in fragment macro match",
+	t->get_str ().c_str ());
       return nullptr;
     }
 
@@ -1903,10 +1899,11 @@ Parser<ManagedTokenSource>::parse_macro_match_repetition ()
       lexer.skip_token ();
       break;
     default:
-      rust_error_at (t->get_locus (),
-		     "expected macro repetition operator ('*', '+', or '?') in "
-		     "macro match - found '%s'",
-		     t->get_token_description ());
+      rust_error_at (
+	t->get_locus (),
+	"expected macro repetition operator (%<*%>, %<+%>, or %<?%>) in "
+	"macro match - found %<%s%>",
+	t->get_token_description ());
       // skip after somewhere?
       return nullptr;
     }
@@ -1979,7 +1976,7 @@ Parser<ManagedTokenSource>::parse_visibility ()
 	return AST::Visibility::create_in_path (std::move (path));
       }
     default:
-      rust_error_at (t->get_locus (), "unexpected token '%s' in visibility",
+      rust_error_at (t->get_locus (), "unexpected token %<%s%> in visibility",
 		     t->get_token_description ());
       lexer.skip_token ();
       return AST::Visibility::create_error ();
@@ -2051,7 +2048,7 @@ Parser<ManagedTokenSource>::parse_module (
     default:
       rust_error_at (
 	t->get_locus (),
-	"unexpected token '%s' in module declaration/definition item",
+	"unexpected token %<%s%> in module declaration/definition item",
 	t->get_token_description ());
       lexer.skip_token ();
       return nullptr;
@@ -2093,9 +2090,10 @@ Parser<ManagedTokenSource>::parse_extern_crate (
       lexer.skip_token ();
       break;
     default:
-      rust_error_at (crate_name_tok->get_locus (),
-		     "expecting crate name (identifier or 'self'), found '%s'",
-		     crate_name_tok->get_token_description ());
+      rust_error_at (
+	crate_name_tok->get_locus (),
+	"expecting crate name (identifier or %<self%>), found %<%s%>",
+	crate_name_tok->get_token_description ());
       skip_after_semicolon ();
       return nullptr;
     }
@@ -2132,9 +2130,10 @@ Parser<ManagedTokenSource>::parse_extern_crate (
       lexer.skip_token ();
       break;
     default:
-      rust_error_at (as_name_tok->get_locus (),
-		     "expecting as clause name (identifier or '_'), found '%s'",
-		     as_name_tok->get_token_description ());
+      rust_error_at (
+	as_name_tok->get_locus (),
+	"expecting as clause name (identifier or %<_%>), found %<%s%>",
+	as_name_tok->get_token_description ());
       skip_after_semicolon ();
       return nullptr;
     }
@@ -2280,8 +2279,8 @@ Parser<ManagedTokenSource>::parse_use_tree ()
 		return nullptr;
 	      }
 
-	    // TODO: find way to determine whether GLOBAL or NO_PATH path type -
-	    // placeholder
+	    /* TODO: find way to determine whether GLOBAL or NO_PATH path type -
+	     * placeholder */
 	    return std::unique_ptr<AST::UseTreeList> (
 	      new AST::UseTreeList (AST::UseTreeList::NO_PATH,
 				    AST::SimplePath::create_empty (),
@@ -2290,15 +2289,14 @@ Parser<ManagedTokenSource>::parse_use_tree ()
 	case AS:
 	  // this is not allowed
 	  rust_error_at (t->get_locus (),
-			 "use declaration with rebind 'as' requires a valid "
+			 "use declaration with rebind %<as%> requires a valid "
 			 "simple path - none found.");
 	  skip_after_semicolon ();
 	  return nullptr;
 	default:
 	  rust_error_at (t->get_locus (),
-			 "unexpected token '%s' in use tree with no valid "
-			 "simple path (i.e. list or "
-			 "glob use tree)",
+			 "unexpected token %<%s%> in use tree with no valid "
+			 "simple path (i.e. list or glob use tree)",
 			 t->get_token_description ());
 	  skip_after_semicolon ();
 	  return nullptr;
@@ -2382,11 +2380,11 @@ Parser<ManagedTokenSource>::parse_use_tree ()
 					  std::move (path), locus,
 					  std::string ("_")));
 	      default:
-		rust_error_at (
-		  t->get_locus (),
-		  "unexpected token '%s' in use tree with as clause - expected "
-		  "identifier or '_'",
-		  t->get_token_description ());
+		rust_error_at (t->get_locus (),
+			       "unexpected token %<%s%> in use tree with as "
+			       "clause - expected "
+			       "identifier or %<_%>",
+			       t->get_token_description ());
 		skip_after_semicolon ();
 		return nullptr;
 	      }
@@ -2408,7 +2406,7 @@ Parser<ManagedTokenSource>::parse_use_tree ()
 				    locus));
 	default:
 	  rust_error_at (t->get_locus (),
-			 "unexpected token '%s' in use tree with valid path",
+			 "unexpected token %<%s%> in use tree with valid path",
 			 t->get_token_description ());
 	  // skip_after_semicolon();
 	  return nullptr;
@@ -2766,8 +2764,7 @@ Parser<ManagedTokenSource>::parse_lifetime_params ()
 {
   std::vector<std::unique_ptr<AST::LifetimeParam> > lifetime_params;
 
-  // if end_token is not specified, it defaults to EOF, so should work fine
-  while (lexer.peek_token ()->get_id () != end_token)
+  while (lexer.peek_token ()->get_id () != END_OF_FILE)
     {
       AST::LifetimeParam lifetime_param = parse_lifetime_param ();
 
@@ -2781,7 +2778,7 @@ Parser<ManagedTokenSource>::parse_lifetime_params ()
 	new AST::LifetimeParam (std::move (lifetime_param))));
 
       if (lexer.peek_token ()->get_id () != COMMA)
-	  break;
+	break;
 
       // skip commas, including trailing commas
       lexer.skip_token ();
@@ -2808,16 +2805,18 @@ Parser<ManagedTokenSource>::parse_lifetime_params (EndTokenPred is_end_token)
 
       if (lifetime_param.is_error ())
 	{
-      // TODO: is it worth throwing away all lifetime params just because one failed?
-      rust_error_at (lexer.peek_token ()->get_locus (), "failed to parse lifetime param in lifetime params");
-      return {};
+	  // TODO: is it worth throwing away all lifetime params just because
+	  // one failed?
+	  rust_error_at (lexer.peek_token ()->get_locus (),
+			 "failed to parse lifetime param in lifetime params");
+	  return {};
 	}
 
       lifetime_params.push_back (std::unique_ptr<AST::LifetimeParam> (
 	new AST::LifetimeParam (std::move (lifetime_param))));
 
       if (lexer.peek_token ()->get_id () != COMMA)
-	  break;
+	break;
 
       // skip commas, including trailing commas
       lexer.skip_token ();
@@ -2844,14 +2843,14 @@ Parser<ManagedTokenSource>::parse_lifetime_params_objs ()
 
       if (lifetime_param.is_error ())
 	{
-    // not an error as only way to exit if trailing comma
+	  // not an error as only way to exit if trailing comma
 	  break;
 	}
 
       lifetime_params.push_back (std::move (lifetime_param));
 
       if (lexer.peek_token ()->get_id () != COMMA)
-	  break;
+	break;
 
       // skip commas, including trailing commas
       lexer.skip_token ();
@@ -2868,7 +2867,8 @@ Parser<ManagedTokenSource>::parse_lifetime_params_objs ()
 template <typename ManagedTokenSource>
 template <typename EndTokenPred>
 std::vector<AST::LifetimeParam>
-Parser<ManagedTokenSource>::parse_lifetime_params_objs (EndTokenPred is_end_token)
+Parser<ManagedTokenSource>::parse_lifetime_params_objs (
+  EndTokenPred is_end_token)
 {
   std::vector<AST::LifetimeParam> lifetime_params;
 
@@ -2878,15 +2878,17 @@ Parser<ManagedTokenSource>::parse_lifetime_params_objs (EndTokenPred is_end_toke
 
       if (lifetime_param.is_error ())
 	{
-      // TODO: is it worth throwing away all lifetime params just because one failed?
-      rust_error_at (lexer.peek_token ()->get_locus (), "failed to parse lifetime param in lifetime params");
-      return {};
+	  // TODO: is it worth throwing away all lifetime params just because
+	  // one failed?
+	  rust_error_at (lexer.peek_token ()->get_locus (),
+			 "failed to parse lifetime param in lifetime params");
+	  return {};
 	}
 
       lifetime_params.push_back (std::move (lifetime_param));
 
       if (lexer.peek_token ()->get_id () != COMMA)
-	  break;
+	break;
 
       // skip commas, including trailing commas
       lexer.skip_token ();
@@ -2897,15 +2899,17 @@ Parser<ManagedTokenSource>::parse_lifetime_params_objs (EndTokenPred is_end_toke
   return lifetime_params;
 }
 
-/* Parses various types of generic parameters (templated). Will also consume any trailing
- * comma. Has extra is_end_token predicate checking.
+/* Parses various types of generic parameters (templated). Will also consume any
+ * trailing comma. Has extra is_end_token predicate checking.
  * TODO: is this best solution? implements most of the same algorithm. */
 template <typename ManagedTokenSource>
 template <typename ParseFunction, typename EndTokenPred>
 auto
-Parser<ManagedTokenSource>::parse_generic_params (ParseFunction parsing_function, EndTokenPred is_end_token, std::string error_msg) -> std::vector<decltype(parsing_function ())>
+Parser<ManagedTokenSource>::parse_generic_params (
+  ParseFunction parsing_function, EndTokenPred is_end_token,
+  std::string error_msg) -> std::vector<decltype (parsing_function ())>
 {
-  std::vector<decltype(parsing_function ())> params;
+  std::vector<decltype (parsing_function ())> params;
 
   while (!is_end_token (lexer.peek_token ()->get_id ()))
     {
@@ -2913,15 +2917,15 @@ Parser<ManagedTokenSource>::parse_generic_params (ParseFunction parsing_function
 
       if (param.is_error ())
 	{
-      // TODO: is it worth throwing away all params just because one failed?
-      rust_error_at (lexer.peek_token ()->get_locus (), error_msg.c_str ());
-      return {};
+	  // TODO: is it worth throwing away all params just because one failed?
+	  rust_error_at (lexer.peek_token ()->get_locus (), error_msg.c_str ());
+	  return {};
 	}
 
       params.push_back (std::move (param));
 
       if (lexer.peek_token ()->get_id () != COMMA)
-	  break;
+	break;
 
       // skip commas, including trailing commas
       lexer.skip_token ();
@@ -3305,7 +3309,8 @@ Parser<ManagedTokenSource>::parse_for_lifetimes ()
       return params;
     }
 
-  // cannot specify end token due to parsing problems with '>' tokens being nested
+  // cannot specify end token due to parsing problems with '>' tokens being
+  // nested
   params = parse_lifetime_params_objs (is_right_angle_tok);
 
   if (!skip_generics_right_angle ())
@@ -3662,7 +3667,7 @@ Parser<ManagedTokenSource>::parse_struct (
 			       std::move (outer_attrs), locus));
     default:
       rust_error_at (t->get_locus (),
-		     "unexpected token '%s' in struct declaration",
+		     "unexpected token %<%s%> in struct declaration",
 		     t->get_token_description ());
       // skip somewhere?
       return nullptr;
@@ -4081,10 +4086,11 @@ Parser<ManagedTokenSource>::parse_const_item (
       lexer.skip_token ();
       break;
     default:
-      rust_error_at (ident_tok->get_locus (),
-		     "expected item name (identifier or '_') in constant item "
-		     "declaration - found '%s'",
-		     ident_tok->get_token_description ());
+      rust_error_at (
+	ident_tok->get_locus (),
+	"expected item name (identifier or %<_%>) in constant item "
+	"declaration - found %<%s%>",
+	ident_tok->get_token_description ());
       skip_after_semicolon ();
       return nullptr;
     }
@@ -4342,14 +4348,13 @@ Parser<ManagedTokenSource>::parse_trait_item ()
 	    break;
 	  case LEFT_CURLY:
 	    definition = parse_block_expr ();
-	    // FIXME: are these outer attributes meant to be passed into the
-	    // block?
+	    /* FIXME: are these outer attributes meant to be passed into the
+	     * block? */
 	    break;
 	  default:
 	    rust_error_at (t->get_locus (),
-			   "expected ';' or definiton at the end of trait %s "
-			   "definition - found '%s' "
-			   "instead",
+			   "expected %<;%> or definiton at the end of trait %s "
+			   "definition - found %<%s%> instead",
 			   is_method ? "method" : "function",
 			   t->get_token_description ());
 	    // skip?
@@ -4402,8 +4407,8 @@ Parser<ManagedTokenSource>::parse_trait_item ()
 	  {
 	    return macro_invoc;
 	  }
-	// FIXME: macro invocations can only start with certain tokens. be more
-	// picky with these?
+	/* FIXME: macro invocations can only start with certain tokens. be more
+	 * picky with these? */
       }
     }
 }
@@ -4739,16 +4744,17 @@ Parser<ManagedTokenSource>::parse_inherent_impl_item ()
 								 outer_attrs));
 	      default:
 		rust_error_at (t->get_locus (),
-			       "unexpected token '%s' in some sort of const "
+			       "unexpected token %<%s%> in some sort of const "
 			       "item in inherent impl",
 			       t->get_token_description ());
 		lexer.skip_token (1); // TODO: is this right thing to do?
 		return nullptr;
 	      }
 	  default:
-	    rust_error_at (t->get_locus (),
-			   "unrecognised token '%s' for item in inherent impl",
-			   t->get_token_description ());
+	    rust_error_at (
+	      t->get_locus (),
+	      "unrecognised token %<%s%> for item in inherent impl",
+	      t->get_token_description ());
 	    // skip?
 	    return nullptr;
 	  }
@@ -4776,17 +4782,17 @@ Parser<ManagedTokenSource>::parse_inherent_impl_item ()
 	  return parse_inherent_impl_function_or_method (
 	    AST::Visibility::create_error (), std::move (outer_attrs));
 	default:
-	  rust_error_at (
-	    t->get_locus (),
-	    "unexpected token '%s' in some sort of const item in inherent impl",
-	    t->get_token_description ());
+	  rust_error_at (t->get_locus (),
+			 "unexpected token %<%s%> in some sort of const item "
+			 "in inherent impl",
+			 t->get_token_description ());
 	  lexer.skip_token (1); // TODO: is this right thing to do?
 	  return nullptr;
 	}
       gcc_unreachable ();
     default:
       rust_error_at (t->get_locus (),
-		     "unrecognised token '%s' for item in inherent impl",
+		     "unrecognised token %<%s%> for item in inherent impl",
 		     t->get_token_description ());
       // skip?
       return nullptr;
@@ -4959,7 +4965,7 @@ Parser<ManagedTokenSource>::parse_trait_impl_item ()
 							      outer_attrs));
 	      default:
 		rust_error_at (t->get_locus (),
-			       "unexpected token '%s' in some sort of const "
+			       "unexpected token %<%s%> in some sort of const "
 			       "item in trait impl",
 			       t->get_token_description ());
 		lexer.skip_token (1); // TODO: is this right thing to do?
@@ -4967,7 +4973,7 @@ Parser<ManagedTokenSource>::parse_trait_impl_item ()
 	      }
 	  default:
 	    rust_error_at (t->get_locus (),
-			   "unrecognised token '%s' for item in trait impl",
+			   "unrecognised token %<%s%> for item in trait impl",
 			   t->get_token_description ());
 	    // skip?
 	    return nullptr;
@@ -4998,7 +5004,7 @@ Parser<ManagedTokenSource>::parse_trait_impl_item ()
 	default:
 	  rust_error_at (
 	    t->get_locus (),
-	    "unexpected token '%s' in some sort of const item in trait impl",
+	    "unexpected token %<%s%> in some sort of const item in trait impl",
 	    t->get_token_description ());
 	  lexer.skip_token (1); // TODO: is this right thing to do?
 	  return nullptr;
@@ -5006,7 +5012,7 @@ Parser<ManagedTokenSource>::parse_trait_impl_item ()
       gcc_unreachable ();
     default:
       rust_error_at (t->get_locus (),
-		     "unrecognised token '%s' for item in trait impl",
+		     "unrecognised token %<%s%> for item in trait impl",
 		     t->get_token_description ());
       // skip?
       return nullptr;
@@ -5345,8 +5351,7 @@ Parser<ManagedTokenSource>::parse_external_item ()
 		  {
 		    rust_error_at (t->get_locus (),
 				   "expected comma or right parentheses in "
-				   "named function parameters, "
-				   "found '%s'",
+				   "named function parameters, found %<%s%>",
 				   t->get_token_description ());
 		  }
 		else
@@ -5399,9 +5404,10 @@ Parser<ManagedTokenSource>::parse_external_item ()
       }
     default:
       // error
-      rust_error_at (t->get_locus (),
-		     "unrecognised token '%s' in extern block item declaration",
-		     t->get_token_description ());
+      rust_error_at (
+	t->get_locus (),
+	"unrecognised token %<%s%> in extern block item declaration",
+	t->get_token_description ());
       skip_after_semicolon ();
       return nullptr;
     }
@@ -5763,10 +5769,10 @@ Parser<ManagedTokenSource>::parse_path_generic_args ()
 
   // skip any trailing commas
   if (lexer.peek_token ()->get_id () == COMMA)
-      lexer.skip_token ();
+    lexer.skip_token ();
 
   if (!skip_generics_right_angle ())
-      return AST::GenericArgs::create_empty ();
+    return AST::GenericArgs::create_empty ();
 
   lifetime_args.shrink_to_fit ();
   type_args.shrink_to_fit ();
@@ -5893,19 +5899,22 @@ Parser<ManagedTokenSource>::parse_type_path_function ()
       std::unique_ptr<AST::Type> type = parse_type ();
       if (type == nullptr)
 	{
-	  // this is an error as there should've been a ')' there if there wasn't a type
-    rust_error_at (lexer.peek_token ()->get_locus (), "failed to parse type in parameters of type path function");
-    // skip somewhere?
-    return AST::TypePathFunction::create_error ();
+	  // this is an error as there should've been a ')' there if there
+	  // wasn't a type
+	  rust_error_at (
+	    lexer.peek_token ()->get_locus (),
+	    "failed to parse type in parameters of type path function");
+	  // skip somewhere?
+	  return AST::TypePathFunction::create_error ();
 	}
 
       inputs.push_back (std::move (type));
 
       // skip commas, including trailing commas
       if (lexer.peek_token ()->get_id () != COMMA)
-	  break;
+	break;
 
-	  lexer.skip_token ();
+      lexer.skip_token ();
     }
 
   if (!skip_token (RIGHT_PAREN))
@@ -6361,7 +6370,7 @@ Parser<ManagedTokenSource>::parse_method ()
 
   // skip comma if it exists
   if (lexer.peek_token ()->get_id () == COMMA)
-      lexer.skip_token ();
+    lexer.skip_token ();
 
   // parse function parameters
   std::vector<AST::FunctionParam> function_params = parse_function_params ();
@@ -6539,11 +6548,11 @@ Parser<ManagedTokenSource>::parse_expr_stmt_with_block (
       expr_parsed = parse_labelled_loop_expr (std::move (outer_attrs));
       break;
     default:
-      rust_error_at (t->get_locus (),
-		     "could not recognise expr beginning with '%s' as an expr "
-		     "with block in parsing "
-		     "expr statement.",
-		     t->get_token_description ());
+      rust_error_at (
+	t->get_locus (),
+	"could not recognise expr beginning with %<%s%> as an expr "
+	"with block in parsing expr statement.",
+	t->get_token_description ());
       skip_after_next_block ();
       return nullptr;
     }
@@ -6854,10 +6863,10 @@ Parser<ManagedTokenSource>::parse_closure_expr (
 	}
       break;
     default:
-      rust_error_at (
-	t->get_locus (),
-	"unexpected token '%s' in closure expression - expected '|' or '||'",
-	t->get_token_description ());
+      rust_error_at (t->get_locus (),
+		     "unexpected token %<%s%> in closure expression - expected "
+		     "%<|%> or %<||%>",
+		     t->get_token_description ());
       // skip somewhere?
       return nullptr;
     }
@@ -6980,7 +6989,7 @@ Parser<ManagedTokenSource>::parse_literal_expr (
     default:
       // error - cannot be a literal expr
       rust_error_at (t->get_locus (),
-		     "unexpected token '%s' when parsing literal expression",
+		     "unexpected token %<%s%> when parsing literal expression",
 		     t->get_token_description ());
       // skip?
       return nullptr;
@@ -7131,8 +7140,7 @@ Parser<ManagedTokenSource>::parse_if_expr (
     {
       rust_error_at (lexer.peek_token ()->get_locus (),
 		     "if let expression probably exists, but is being parsed "
-		     "as an if expression. This may "
-		     "be a parser error.");
+		     "as an if expression. This may be a parser error.");
       // skip somewhere?
       return nullptr;
     }
@@ -7242,7 +7250,7 @@ Parser<ManagedTokenSource>::parse_if_expr (
 	default:
 	  // error - invalid token
 	  rust_error_at (t->get_locus (),
-			 "unexpected token '%s' after else in if expression",
+			 "unexpected token %<%s%> after else in if expression",
 			 t->get_token_description ());
 	  // skip somewhere?
 	  return nullptr;
@@ -7268,8 +7276,7 @@ Parser<ManagedTokenSource>::parse_if_let_expr (
     {
       rust_error_at (lexer.peek_token ()->get_locus (),
 		     "if expression probably exists, but is being parsed as an "
-		     "if let expression. This may "
-		     "be a parser error.");
+		     "if let expression. This may be a parser error.");
       // skip somewhere?
       return nullptr;
     }
@@ -7405,7 +7412,7 @@ Parser<ManagedTokenSource>::parse_if_let_expr (
 	  // error - invalid token
 	  rust_error_at (
 	    t->get_locus (),
-	    "unexpected token '%s' after else in if let expression",
+	    "unexpected token %<%s%> after else in if let expression",
 	    t->get_token_description ());
 	  // skip somewhere?
 	  return nullptr;
@@ -7425,9 +7432,9 @@ Parser<ManagedTokenSource>::parse_loop_expr (
 {
   Location locus = Linemap::unknown_location ();
   if (label.is_error ())
-      locus = lexer.peek_token ()->get_locus ();
+    locus = lexer.peek_token ()->get_locus ();
   else
-      locus = label.get_locus ();
+    locus = label.get_locus ();
   skip_token (LOOP);
 
   // parse loop body, which is required
@@ -7453,9 +7460,9 @@ Parser<ManagedTokenSource>::parse_while_loop_expr (
 {
   Location locus = Linemap::unknown_location ();
   if (label.is_error ())
-      locus = lexer.peek_token ()->get_locus ();
+    locus = lexer.peek_token ()->get_locus ();
   else
-      locus = label.get_locus ();
+    locus = label.get_locus ();
   skip_token (WHILE);
 
   // ensure it isn't a while let loop
@@ -7508,9 +7515,9 @@ Parser<ManagedTokenSource>::parse_while_let_loop_expr (
 {
   Location locus = Linemap::unknown_location ();
   if (label.is_error ())
-      locus = lexer.peek_token ()->get_locus ();
+    locus = lexer.peek_token ()->get_locus ();
   else
-      locus = label.get_locus ();
+    locus = label.get_locus ();
   skip_token (WHILE);
 
   /* check for possible accidental recognition of a while loop as a while let
@@ -7578,9 +7585,9 @@ Parser<ManagedTokenSource>::parse_for_loop_expr (
 {
   Location locus = Linemap::unknown_location ();
   if (label.is_error ())
-      locus = lexer.peek_token ()->get_locus ();
+    locus = lexer.peek_token ()->get_locus ();
   else
-      locus = label.get_locus ();
+    locus = label.get_locus ();
   skip_token (FOR);
 
   // parse pattern, which is required
@@ -7644,7 +7651,7 @@ Parser<ManagedTokenSource>::parse_labelled_loop_expr (
     {
       rust_error_at (lexer.peek_token ()->get_locus (),
 		     "expected lifetime in labelled loop expr (to parse loop "
-		     "label) - found '%s'",
+		     "label) - found %<%s%>",
 		     lexer.peek_token ()->get_token_description ());
       // skip?
       return nullptr;
@@ -7683,7 +7690,7 @@ Parser<ManagedTokenSource>::parse_labelled_loop_expr (
     default:
       // error
       rust_error_at (t->get_locus (),
-		     "unexpected token '%s' when parsing labelled loop",
+		     "unexpected token %<%s%> when parsing labelled loop",
 		     t->get_token_description ());
       // skip?
       return nullptr;
@@ -8083,9 +8090,9 @@ Parser<ManagedTokenSource>::parse_array_expr (
 	{
 	  // single-element array expression
 	  std::vector<std::unique_ptr<AST::Expr> > exprs;
-    exprs.reserve (1);
+	  exprs.reserve (1);
 	  exprs.push_back (std::move (initial_expr));
-    exprs.shrink_to_fit ();
+	  exprs.shrink_to_fit ();
 
 	  std::unique_ptr<AST::ArrayElemsValues> array_elems (
 	    new AST::ArrayElemsValues (std::move (exprs)));
@@ -8127,7 +8134,7 @@ Parser<ManagedTokenSource>::parse_array_expr (
 
 	  skip_token (RIGHT_SQUARE);
 
-    exprs.shrink_to_fit ();
+	  exprs.shrink_to_fit ();
 
 	  std::unique_ptr<AST::ArrayElemsValues> array_elems (
 	    new AST::ArrayElemsValues (std::move (exprs)));
@@ -8141,7 +8148,7 @@ Parser<ManagedTokenSource>::parse_array_expr (
 	  // error
 	  rust_error_at (
 	    lexer.peek_token ()->get_locus (),
-	    "unexpected token '%s' in array expression (arrayelems)",
+	    "unexpected token %<%s%> in array expression (arrayelems)",
 	    lexer.peek_token ()->get_token_description ());
 	  // skip somewhere?
 	  return nullptr;
@@ -8282,9 +8289,9 @@ Parser<ManagedTokenSource>::parse_grouped_or_tuple_expr (
       // error
       const_TokenPtr t = lexer.peek_token ();
       rust_error_at (t->get_locus (),
-		     "unexpected token '%s' in grouped or tuple expression "
-		     "(parenthesised expression) - "
-		     "expected ')' for grouped expr and ',' for tuple expr",
+		     "unexpected token %<%s%> in grouped or tuple expression "
+		     "(parenthesised expression) - expected %<)%> for grouped "
+		     "expr and %<,%> for tuple expr",
 		     t->get_token_description ());
       // skip somewhere?
       return nullptr;
@@ -8462,8 +8469,8 @@ Parser<ManagedTokenSource>::parse_type ()
       }
     case LEFT_PAREN:
       /* tuple type or parenthesised type - requires further disambiguation (the
-       * usual). ok apparently can be a parenthesised TraitBound too, so could be
-       * TraitObjectTypeOneBound or TraitObjectType */
+       * usual). ok apparently can be a parenthesised TraitBound too, so could
+       * be TraitObjectTypeOneBound or TraitObjectType */
       return parse_paren_prefixed_type ();
     case FOR:
       // TraitObjectTypeOneBound or BareFunctionType
@@ -8612,7 +8619,7 @@ Parser<ManagedTokenSource>::parse_type ()
 	  }
       }
     default:
-      rust_error_at (t->get_locus (), "unrecognised token '%s' in type",
+      rust_error_at (t->get_locus (), "unrecognised token %<%s%> in type",
 		     t->get_token_description ());
       return nullptr;
     }
@@ -8837,9 +8844,8 @@ Parser<ManagedTokenSource>::parse_for_prefixed_type ()
     default:
       // error
       rust_error_at (t->get_locus (),
-		     "unrecognised token '%s' in bare function type or trait "
-		     "object type or trait "
-		     "object type one bound",
+		     "unrecognised token %<%s%> in bare function type or trait "
+		     "object type or trait object type one bound",
 		     t->get_token_description ());
       return nullptr;
     }
@@ -9047,7 +9053,7 @@ Parser<ManagedTokenSource>::parse_raw_pointer_type ()
       break;
     default:
       rust_error_at (t->get_locus (),
-		     "unrecognised token '%s' in raw pointer type",
+		     "unrecognised token %<%s%> in raw pointer type",
 		     t->get_token_description ());
       return nullptr;
     }
@@ -9118,7 +9124,7 @@ Parser<ManagedTokenSource>::parse_slice_or_array_type ()
       // error
       rust_error_at (
 	t->get_locus (),
-	"unrecognised token '%s' in slice or array type after inner type",
+	"unrecognised token %<%s%> in slice or array type after inner type",
 	t->get_token_description ());
       return nullptr;
     }
@@ -9241,8 +9247,8 @@ Parser<ManagedTokenSource>::parse_type_no_bounds ()
       }
     case LEFT_PAREN:
       /* tuple type or parenthesised type - requires further disambiguation (the
-       * usual). ok apparently can be a parenthesised TraitBound too, so could be
-       * TraitObjectTypeOneBound */
+       * usual). ok apparently can be a parenthesised TraitBound too, so could
+       * be TraitObjectTypeOneBound */
       return parse_paren_prefixed_type_no_bounds ();
     case FOR:
     case ASYNC:
@@ -9259,10 +9265,10 @@ Parser<ManagedTokenSource>::parse_type_no_bounds ()
 	  /* cannot be one bound because lifetime prevents it from being
 	   * traitbound not allowed as type no bounds, only here for error
 	   * message */
-	  rust_error_at (lexer.peek_token ()->get_locus (),
-			 "lifetime (probably lifetime bound, in type param "
-			 "bounds, in ImplTraitType) is "
-			 "not allowed in TypeNoBounds");
+	  rust_error_at (
+	    lexer.peek_token ()->get_locus (),
+	    "lifetime (probably lifetime bound, in type param "
+	    "bounds, in ImplTraitType) is not allowed in TypeNoBounds");
 	  return nullptr;
 	}
       else
@@ -9351,7 +9357,7 @@ Parser<ManagedTokenSource>::parse_type_no_bounds ()
       }
     default:
       rust_error_at (t->get_locus (),
-		     "unrecognised token '%s' in type no bounds",
+		     "unrecognised token %<%s%> in type no bounds",
 		     t->get_token_description ());
       return nullptr;
     }
@@ -9510,16 +9516,17 @@ Parser<ManagedTokenSource>::parse_literal_or_range_pattern ()
 	  break;
 	default:
 	  rust_error_at (range_lower->get_locus (),
-			 "token type '%s' cannot be parsed as range pattern "
+			 "token type %<%s%> cannot be parsed as range pattern "
 			 "bound or literal after minus symbol",
 			 range_lower->get_token_description ());
 	  return nullptr;
 	}
       break;
     default:
-      rust_error_at (range_lower->get_locus (),
-		     "token type '%s' cannot be parsed as range pattern bound",
-		     range_lower->get_token_description ());
+      rust_error_at (
+	range_lower->get_locus (),
+	"token type %<%s%> cannot be parsed as range pattern bound",
+	range_lower->get_token_description ());
       return nullptr;
     }
 
@@ -9613,7 +9620,7 @@ Parser<ManagedTokenSource>::parse_range_pattern_bound ()
 	      range_lower_locus, true));
 	default:
 	  rust_error_at (range_lower->get_locus (),
-			 "token type '%s' cannot be parsed as range pattern "
+			 "token type %<%s%> cannot be parsed as range pattern "
 			 "bound after minus symbol",
 			 range_lower->get_token_description ());
 	  return nullptr;
@@ -9652,9 +9659,10 @@ Parser<ManagedTokenSource>::parse_range_pattern_bound ()
 	  new AST::RangePatternBoundQualPath (std::move (path)));
       }
     default:
-      rust_error_at (range_lower->get_locus (),
-		     "token type '%s' cannot be parsed as range pattern bound",
-		     range_lower->get_token_description ());
+      rust_error_at (
+	range_lower->get_locus (),
+	"token type %<%s%> cannot be parsed as range pattern bound",
+	range_lower->get_token_description ());
       return nullptr;
     }
 }
@@ -9702,8 +9710,8 @@ Parser<ManagedTokenSource>::parse_pattern ()
 	}
       else
 	{
-	  rust_error_at (t->get_locus (), "unexpected token '-' in pattern - "
-					  "did you forget an integer literal?");
+	  rust_error_at (t->get_locus (), "unexpected token %<-%> in pattern - "
+					  "did you forget an integer literal");
 	  return nullptr;
 	}
     case UNDERSCORE:
@@ -9834,7 +9842,7 @@ Parser<ManagedTokenSource>::parse_pattern ()
 	  }
       }
     default:
-      rust_error_at (t->get_locus (), "unexpected token '%s' in pattern",
+      rust_error_at (t->get_locus (), "unexpected token %<%s%> in pattern",
 		     t->get_token_description ());
       return nullptr;
     }
@@ -9860,7 +9868,7 @@ Parser<ManagedTokenSource>::parse_reference_pattern ()
       break;
     default:
       rust_error_at (t->get_locus (),
-		     "unexpected token '%s' in reference pattern",
+		     "unexpected token %<%s%> in reference pattern",
 		     t->get_token_description ());
       return nullptr;
     }
@@ -10060,7 +10068,7 @@ Parser<ManagedTokenSource>::parse_grouped_or_tuple_pattern ()
     default:
       // error
       rust_error_at (t->get_locus (),
-		     "unrecognised token '%s' in grouped or tuple pattern "
+		     "unrecognised token %<%s%> in grouped or tuple pattern "
 		     "after first pattern",
 		     t->get_token_description ());
       return nullptr;
@@ -10446,7 +10454,7 @@ Parser<ManagedTokenSource>::parse_tuple_struct_items ()
     default:
       // error
       rust_error_at (t->get_locus (),
-		     "unexpected token '%s' in tuple struct items",
+		     "unexpected token %<%s%> in tuple struct items",
 		     t->get_token_description ());
       return nullptr;
     }
@@ -10493,8 +10501,8 @@ Parser<ManagedTokenSource>::parse_struct_pattern_elems ()
     }
 
   /* FIXME: this method of parsing prevents parsing any outer attributes on the
-   * .. - also there seems to be no distinction between having etc and not having
-   * etc. */
+   * .. - also there seems to be no distinction between having etc and not
+   * having etc. */
   if (lexer.peek_token ()->get_id () == DOT_DOT)
     {
       lexer.skip_token ();
@@ -10588,7 +10596,7 @@ Parser<ManagedTokenSource>::parse_struct_pattern_field ()
 	default:
 	  // error
 	  rust_error_at (t->get_locus (),
-			 "unrecognised token '%s' in struct pattern field",
+			 "unrecognised token %<%s%> in struct pattern field",
 			 t->get_token_description ());
 	  return nullptr;
 	}
@@ -10722,9 +10730,8 @@ Parser<ManagedTokenSource>::parse_stmt_or_expr_without_block ()
 	    }
 	  default:
 	    rust_error_at (t2->get_locus (),
-			   "unrecognised token '%s' after parsing unsafe - "
-			   "expected beginning of "
-			   "expression or statement",
+			   "unrecognised token %<%s%> after parsing unsafe - "
+			   "expected beginning of expression or statement",
 			   t->get_token_description ());
 	    // skip somewhere?
 	    return ExprOrStmt::create_error ();
@@ -10925,7 +10932,7 @@ Parser<ManagedTokenSource>::parse_path_based_stmt_or_expr (
 	  default:
 	    rust_error_at (
 	      t3->get_locus (),
-	      "unrecognised token '%s' in macro invocation - (opening) "
+	      "unrecognised token %<%s%> in macro invocation - (opening) "
 	      "delimiter expected",
 	      t3->get_token_description ());
 	    return ExprOrStmt::create_error ();
@@ -10946,7 +10953,7 @@ Parser<ManagedTokenSource>::parse_path_based_stmt_or_expr (
 		rust_error_at (
 		  t3->get_locus (),
 		  "failed to parse token tree for macro invocation (or semi) - "
-		  "found '%s'",
+		  "found %<%s%>",
 		  t3->get_token_description ());
 		return ExprOrStmt::create_error ();
 	      }
@@ -10995,12 +11002,14 @@ Parser<ManagedTokenSource>::parse_path_based_stmt_or_expr (
 	else
 	  {
 	    // tokens don't match opening delimiters, so produce error
-	    rust_error_at (
-	      t2->get_locus (),
-	      "unexpected token '%s' - expecting closing delimiter '%s' (for a "
-	      "macro invocation)",
-	      t2->get_token_description (),
-	      (type == AST::PARENS ? ")" : (type == AST::SQUARE ? "]" : "}")));
+	    rust_error_at (t2->get_locus (),
+			   "unexpected token %<%s%> - expecting closing "
+			   "delimiter %<%s%> (for a "
+			   "macro invocation)",
+			   t2->get_token_description (),
+			   (type == AST::PARENS
+			      ? ")"
+			      : (type == AST::SQUARE ? "]" : "}")));
 	    return ExprOrStmt::create_error ();
 	  }
       }
@@ -11176,7 +11185,7 @@ Parser<ManagedTokenSource>::parse_struct_expr_field ()
       return nullptr;
     default:
       rust_error_at (t->get_locus (),
-		     "unrecognised token '%s' as first token of struct expr "
+		     "unrecognised token %<%s%> as first token of struct expr "
 		     "field - expected identifier or int literal",
 		     t->get_token_description ());
       return nullptr;
@@ -11219,10 +11228,11 @@ Parser<ManagedTokenSource>::parse_macro_invocation_maybe_semi (
       type = AST::CURLY;
       break;
     default:
-      rust_error_at (t3->get_locus (),
-		     "unrecognised token '%s' in macro invocation - (opening) "
-		     "delimiter expected",
-		     t3->get_token_description ());
+      rust_error_at (
+	t3->get_locus (),
+	"unrecognised token %<%s%> in macro invocation - (opening) "
+	"delimiter expected",
+	t3->get_token_description ());
       return ExprOrStmt::create_error ();
     }
   lexer.skip_token ();
@@ -11240,7 +11250,7 @@ Parser<ManagedTokenSource>::parse_macro_invocation_maybe_semi (
 	{
 	  rust_error_at (t3->get_locus (),
 			 "failed to parse token tree for macro invocation (or "
-			 "semi) - found '%s'",
+			 "semi) - found %<%s%>",
 			 t3->get_token_description ());
 	  return ExprOrStmt::create_error ();
 	}
@@ -11291,7 +11301,7 @@ Parser<ManagedTokenSource>::parse_macro_invocation_maybe_semi (
       // tokens don't match opening delimiters, so produce error
       rust_error_at (
 	t->get_locus (),
-	"unexpected token '%s' - expecting closing delimiter '%s' (for a "
+	"unexpected token %<%s%> - expecting closing delimiter %<%s%> (for a "
 	"macro invocation)",
 	t->get_token_description (),
 	(type == AST::PARENS ? ")" : (type == AST::SQUARE ? "]" : "}")));
@@ -11304,7 +11314,7 @@ template <typename ManagedTokenSource>
 void
 Parser<ManagedTokenSource>::unexpected_token (const_TokenPtr t)
 {
-  rust_error_at (t->get_locus (), "unexpected %s\n",
+  rust_error_at (t->get_locus (), "unexpected token %<%s%>\n",
 		 t->get_token_description ());
 }
 
@@ -11349,7 +11359,7 @@ Parser<ManagedTokenSource>::expect_token (TokenId token_id)
     }
   else
     {
-      rust_error_at (t->get_locus (), "expecting %s but %s found!\n",
+      rust_error_at (t->get_locus (), "expecting %<%s%> but %<%s%> found\n",
 		     get_token_description (token_id),
 		     t->get_token_description ());
 
@@ -11594,7 +11604,7 @@ Parser<ManagedTokenSource>::null_denotation (
 		  if (path.is_single_segment ())
 		    {
 		      // have to return an identifier expression or something
-          /* HACK: may have to become permanent, but this is my
+		      /* HACK: may have to become permanent, but this is my
 		       * current identifier expression */
 		      return std::unique_ptr<AST::IdentifierExpr> (
 			new AST::IdentifierExpr (tok->get_str (),
@@ -11953,7 +11963,7 @@ Parser<ManagedTokenSource>::null_denotation (
       return parse_array_expr (std::move (outer_attrs), true);
     default:
       rust_error_at (tok->get_locus (),
-		     "found unexpected token '%s' in null denotation",
+		     "found unexpected token %<%s%> in null denotation",
 		     tok->get_token_description ());
       return nullptr;
     }
@@ -12271,7 +12281,7 @@ Parser<ManagedTokenSource>::left_denotation (
 					   restrictions);
     default:
       rust_error_at (tok->get_locus (),
-		     "found unexpected token '%s' in left denotation",
+		     "found unexpected token %<%s%> in left denotation",
 		     tok->get_token_description ());
       return nullptr;
     }
@@ -12309,7 +12319,7 @@ get_lbp_for_arithmetic_or_logical_expr (
       // WTF? should not happen, this is an error
       rust_error_at (
 	Location (),
-	"could not get LBP for ArithmeticOrLogicalExpr - unknown ExprType!");
+	"could not get LBP for ArithmeticOrLogicalExpr - unknown ExprType");
       return LBP_PLUS;
     }
 }
@@ -12591,9 +12601,8 @@ get_lbp_for_comparison_expr (AST::ComparisonExpr::ExprType expr_type)
       return LBP_SMALLER_EQUAL;
     default:
       // WTF? should not happen, this is an error
-      rust_error_at (
-	Location (),
-	"could not get LBP for ComparisonExpr - unknown ExprType!");
+      rust_error_at (Location (),
+		     "could not get LBP for ComparisonExpr - unknown ExprType");
       return LBP_EQUAL;
     }
 }
@@ -12878,7 +12887,7 @@ get_lbp_for_compound_assignment_expr (
       // WTF? should not happen, this is an error
       rust_error_at (
 	Location (),
-	"could not get LBP for CompoundAssignmentExpr - unknown ExprType!");
+	"could not get LBP for CompoundAssignmentExpr - unknown ExprType");
       return LBP_PLUS;
     }
 }
@@ -13168,8 +13177,9 @@ Parser<ManagedTokenSource>::parse_await_expr (
    * as await */
   if (!skip_token (IDENTIFIER))
     {
-      rust_error_at (tok->get_locus (), "failed to skip 'await' in await expr "
-					"- this is probably a deep issue.");
+      rust_error_at (tok->get_locus (),
+		     "failed to skip %<await%> in await expr "
+		     "- this is probably a deep issue");
       // skip somewhere?
       return nullptr;
     }
@@ -13618,10 +13628,11 @@ Parser<ManagedTokenSource>::parse_struct_expr_struct_partial (
 					   std::move (outer_attrs)));
       }
     default:
-      rust_error_at (t->get_locus (),
-		     "unrecognised token '%s' in struct (or enum) expression - "
-		     "expected '}', identifier, int literal, or '..'",
-		     t->get_token_description ());
+      rust_error_at (
+	t->get_locus (),
+	"unrecognised token %<%s%> in struct (or enum) expression - "
+	"expected %<}%>, identifier, int literal, or %<..%>",
+	t->get_token_description ());
       return nullptr;
     }
 }
@@ -13649,9 +13660,9 @@ Parser<ManagedTokenSource>::parse_struct_expr_tuple_partial (
       std::unique_ptr<AST::Expr> expr = parse_expr ();
       if (expr == nullptr)
 	{
-	  rust_error_at (t->get_locus (),
-			 "failed to parse expression in struct "
-			 "(or enum) expression tuple");
+	  rust_error_at (
+	    t->get_locus (),
+	    "failed to parse expression in struct (or enum) expression tuple");
 	  return nullptr;
 	}
       exprs.push_back (std::move (expr));
@@ -13724,7 +13735,7 @@ Parser<ManagedTokenSource>::parse_path_in_expression_pratt (const_TokenPtr tok)
       gcc_fallthrough ();
     default:
       rust_error_at (tok->get_locus (),
-		     "unrecognised token '%s' in path in expression",
+		     "unrecognised token %<%s%> in path in expression",
 		     tok->get_token_description ());
       return AST::PathInExpression::create_error ();
     }
@@ -13847,10 +13858,10 @@ Parser<ManagedTokenSource>::parse_closure_expr_pratt (
 	break;
       }
     default:
-      rust_error_at (
-	tok->get_locus (),
-	"unexpected token '%s' in closure expression - expected '|' or '||'",
-	tok->get_token_description ());
+      rust_error_at (tok->get_locus (),
+		     "unexpected token %<%s%> in closure expression - expected "
+		     "%<|%> or %<||%>",
+		     tok->get_token_description ());
       // skip somewhere?
       return nullptr;
     }