gccrs: Replace some usages of Location with location_t

gcc/rust/ChangeLog:

	* ast/rust-ast-collector.cc: Replace Location with location_t.
	* ast/rust-ast.cc: Likewise.
	* ast/rust-ast.h: Likewise.
	* ast/rust-expr.h: Likewise.
	* ast/rust-item.h: Likewise.
	* ast/rust-macro.h: Likewise.
	* ast/rust-path.cc: Likewise.
	* ast/rust-path.h: Likewise.
	* ast/rust-pattern.h: Likewise.
	* ast/rust-stmt.h: Likewise.
	* ast/rust-type.h: Likewise.
	* backend/rust-compile-base.cc: Likewise.
	* backend/rust-compile-base.h: Likewise.
	* backend/rust-compile-block.cc: Likewise.
	* backend/rust-compile-expr.cc: Likewise.
	* backend/rust-compile-expr.h: Likewise.
	* backend/rust-compile-fnparam.cc: Likewise.
	* backend/rust-compile-fnparam.h: Likewise.
	* backend/rust-compile-intrinsic.cc: Likewise.
	* backend/rust-compile-pattern.cc: Likewise.
	* backend/rust-compile-resolve-path.h: Likewise.
	* backend/rust-compile.cc: Likewise.
	* checks/errors/rust-const-checker.cc: Likewise.
	* checks/errors/rust-const-checker.h: Likewise.
	* checks/errors/rust-unsafe-checker.cc: Likewise.
	* checks/errors/rust-unsafe-checker.h: Likewise.
	* expand/rust-macro-builtins.cc: Likewise.
	* expand/rust-macro-expand.h: Likewise.
	* hir/rust-ast-lower-base.h: Likewise.
	* hir/rust-ast-lower-implitem.h: Likewise.
	* hir/rust-ast-lower-item.cc: Likewise.
	* hir/tree/rust-hir-expr.h: Likewise.
	* hir/tree/rust-hir-item.h: Likewise.
	* hir/tree/rust-hir-path.h: Likewise.
	* hir/tree/rust-hir-pattern.h: Likewise.
	* hir/tree/rust-hir-stmt.h: Likewise.
	* hir/tree/rust-hir-type.h: Likewise.
	* hir/tree/rust-hir.cc: Likewise.
	* hir/tree/rust-hir.h: Likewise.
	* lex/rust-token.h: Likewise.
	* metadata/rust-extern-crate.cc: Likewise.
	* metadata/rust-extern-crate.h: Likewise.
	* parse/rust-parse-impl.h: Likewise.
	* parse/rust-parse.h: Likewise.
	* resolve/rust-ast-resolve-expr.cc: Likewise.
	* resolve/rust-ast-resolve-implitem.h: Likewise.
	* resolve/rust-ast-resolve-pattern.h: Likewise.
	* resolve/rust-ast-resolve-stmt.h: Likewise.
	* resolve/rust-ast-resolve-toplevel.h: Likewise.
	* resolve/rust-ast-resolve-type.h: Likewise.
	* resolve/rust-name-resolver.cc: Likewise.
	* resolve/rust-name-resolver.h: Likewise.
	* rust-diagnostics.cc: Likewise.
	* rust-diagnostics.h: Likewise.
	* rust-gcc.cc: Likewise.
	* rust-session-manager.cc: Likewise.
	* rust-session-manager.h: Likewise.
	* typecheck/rust-casts.cc: Likewise.
	* typecheck/rust-casts.h: Likewise.
	* typecheck/rust-coercion.cc: Likewise.
	* typecheck/rust-coercion.h: Likewise.
	* typecheck/rust-hir-path-probe.cc: Likewise.
	* typecheck/rust-hir-path-probe.h: Likewise.
	* typecheck/rust-hir-trait-reference.cc: Likewise.
	* typecheck/rust-hir-trait-reference.h: Likewise.
	* typecheck/rust-hir-trait-resolve.cc: Likewise.
	* typecheck/rust-hir-type-check-base.cc: Likewise.
	* typecheck/rust-hir-type-check-base.h: Likewise.
	* typecheck/rust-hir-type-check-item.cc: Likewise.
	* typecheck/rust-hir-type-check-item.h: Likewise.
	* typecheck/rust-hir-type-check-path.cc: Likewise.
	* typecheck/rust-hir-type-check-pattern.cc: Likewise.
	* typecheck/rust-hir-type-check-pattern.h: Likewise.
	* typecheck/rust-hir-type-check-type.cc: Likewise.
	* typecheck/rust-hir-type-check-type.h: Likewise.
	* typecheck/rust-hir-type-check.cc: Likewise.
	* typecheck/rust-hir-type-check.h: Likewise.
	* typecheck/rust-substitution-mapper.cc: Likewise.
	* typecheck/rust-substitution-mapper.h: Likewise.
	* typecheck/rust-type-util.cc: Likewise.
	* typecheck/rust-typecheck-context.cc: Likewise.
	* typecheck/rust-tyty-bounds.cc: Likewise.
	* typecheck/rust-tyty-call.h: Likewise.
	* typecheck/rust-tyty-subst.cc: Likewise.
	* typecheck/rust-tyty-subst.h: Likewise.
	* typecheck/rust-tyty-util.cc: Likewise.
	* typecheck/rust-tyty-util.h: Likewise.
	* typecheck/rust-tyty.cc: Likewise.
	* typecheck/rust-tyty.h: Likewise.
	* typecheck/rust-unify.cc: Likewise.
	* typecheck/rust-unify.h: Likewise.
	* util/rust-hir-map.cc: Likewise.
	* util/rust-hir-map.h: Likewise.
	* util/rust-identifier.h: Likewise.

Signed-off-by: Owen Avery <powerboat9.gamer@gmail.com>

11 files changed, 329 insertions, 322 deletions

diff --git a/gcc/rust/ast/rust-ast-collector.cc b/gcc/rust/ast/rust-ast-collector.cc
index ad2ffd0..3b9f457 100644
--- a/gcc/rust/ast/rust-ast-collector.cc
+++ b/gcc/rust/ast/rust-ast-collector.cc
@@ -788,7 +788,7 @@ TokenCollector::visit (QualifiedPathInType &path)
 }
 
 void
-TokenCollector::visit (Literal &lit, Location locus)
+TokenCollector::visit (Literal &lit, location_t locus)
 {
   auto value = lit.as_string ();
   switch (lit.get_lit_type ())
diff --git a/gcc/rust/ast/rust-ast.cc b/gcc/rust/ast/rust-ast.cc
index 4e24f1d..699232c 100644
--- a/gcc/rust/ast/rust-ast.cc
+++ b/gcc/rust/ast/rust-ast.cc
@@ -3643,7 +3643,7 @@ AttributeParser::parse_path_meta_item ()
       case EQUAL: {
 	skip_token ();
 
-	Location locus = peek_token ()->get_locus ();
+	location_t locus = peek_token ()->get_locus ();
 	Literal lit = parse_literal ();
 	if (lit.is_error ())
 	  {
@@ -3848,7 +3848,7 @@ AttributeParser::parse_simple_path_segment ()
 std::unique_ptr<MetaItemLitExpr>
 AttributeParser::parse_meta_item_lit ()
 {
-  Location locus = peek_token ()->get_locus ();
+  location_t locus = peek_token ()->get_locus ();
   LiteralExpr lit_expr (parse_literal (), {}, locus);
   return std::unique_ptr<MetaItemLitExpr> (
     new MetaItemLitExpr (std::move (lit_expr)));
diff --git a/gcc/rust/ast/rust-ast.h b/gcc/rust/ast/rust-ast.h
index 85dae48..bd6a06e 100644
--- a/gcc/rust/ast/rust-ast.h
+++ b/gcc/rust/ast/rust-ast.h
@@ -182,7 +182,7 @@ class Token : public TokenTree, public MacroMatch
   // Token kind.
   TokenId token_id;
   // Token location.
-  Location locus;
+  location_t locus;
   // Associated text (if any) of token.
   std::string str;
   // Token type hint (if any).
@@ -205,7 +205,7 @@ public:
 #if 0
   /* constructor from general text - avoid using if lexer const_TokenPtr is
    * available */
-  Token (TokenId token_id, Location locus, std::string str,
+  Token (TokenId token_id, location_t locus, std::string str,
 	 PrimitiveCoreType type_hint)
     : token_id (token_id), locus (locus), str (std::move (str)),
       type_hint (type_hint)
@@ -370,13 +370,13 @@ public:
 class SimplePathSegment : public PathSegment
 {
   std::string segment_name;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
   // only allow identifiers, "super", "self", "crate", or "$crate"
 public:
   // TODO: put checks in constructor to enforce this rule?
-  SimplePathSegment (std::string segment_name, Location locus)
+  SimplePathSegment (std::string segment_name, location_t locus)
     : segment_name (std::move (segment_name)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
@@ -413,14 +413,14 @@ class SimplePath
 {
   bool opening_scope_resolution;
   std::vector<SimplePathSegment> segments;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
   // Constructor
   SimplePath (std::vector<SimplePathSegment> path_segments,
 	      bool has_opening_scope_resolution = false,
-	      Location locus = UNDEF_LOCATION)
+	      location_t locus = UNDEF_LOCATION)
     : opening_scope_resolution (has_opening_scope_resolution),
       segments (std::move (path_segments)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
@@ -458,7 +458,7 @@ public:
    * ensure that this is a valid identifier in path, so be careful. Also, this
    * will have no location data.
    * TODO have checks? */
-  static SimplePath from_str (std::string str, Location locus)
+  static SimplePath from_str (std::string str, location_t locus)
   {
     std::vector<AST::SimplePathSegment> single_segments
       = {AST::SimplePathSegment (std::move (str), locus)};
@@ -498,7 +498,7 @@ private:
   // bool has_attr_input;
   std::unique_ptr<AttrInput> attr_input;
 
-  Location locus;
+  location_t locus;
 
   bool inner_attribute;
 
@@ -510,7 +510,7 @@ public:
 
   // Constructor has pointer AttrInput for polymorphism reasons
   Attribute (SimplePath path, std::unique_ptr<AttrInput> input,
-	     Location locus = UNDEF_LOCATION, bool inner_attribute = false)
+	     location_t locus = UNDEF_LOCATION, bool inner_attribute = false)
     : path (std::move (path)), attr_input (std::move (input)), locus (locus),
       inner_attribute (inner_attribute)
   {}
@@ -794,7 +794,7 @@ class DelimTokenTree : public TokenTree, public AttrInput
 {
   DelimType delim_type;
   std::vector<std::unique_ptr<TokenTree>> token_trees;
-  Location locus;
+  location_t locus;
 
 protected:
   DelimTokenTree *clone_delim_tok_tree_impl () const
@@ -820,7 +820,7 @@ public:
   DelimTokenTree (DelimType delim_type,
 		  std::vector<std::unique_ptr<TokenTree>> token_trees
 		  = std::vector<std::unique_ptr<TokenTree>> (),
-		  Location locus = UNDEF_LOCATION)
+		  location_t locus = UNDEF_LOCATION)
     : delim_type (delim_type), token_trees (std::move (token_trees)),
       locus (locus)
   {}
@@ -1091,11 +1091,11 @@ class IdentifierExpr : public ExprWithoutBlock
 {
   std::vector<Attribute> outer_attrs;
   Identifier ident;
-  Location locus;
+  location_t locus;
 
 public:
   IdentifierExpr (Identifier ident, std::vector<Attribute> outer_attrs,
-		  Location locus)
+		  location_t locus)
     : outer_attrs (std::move (outer_attrs)), ident (std::move (ident)),
       locus (locus)
   {}
@@ -1277,19 +1277,19 @@ public:
 private:
   LifetimeType lifetime_type;
   std::string lifetime_name;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
   // Constructor
   Lifetime (LifetimeType type, std::string name = std::string (),
-	    Location locus = UNDEF_LOCATION)
+	    location_t locus = UNDEF_LOCATION)
     : TypeParamBound (Analysis::Mappings::get ()->get_next_node_id ()),
       lifetime_type (type), lifetime_name (std::move (name)), locus (locus)
   {}
 
   Lifetime (NodeId id, LifetimeType type, std::string name = std::string (),
-	    Location locus = UNDEF_LOCATION)
+	    location_t locus = UNDEF_LOCATION)
     : TypeParamBound (id), lifetime_type (type),
       lifetime_name (std::move (name)), locus (locus)
   {}
@@ -1366,7 +1366,7 @@ class LifetimeParam : public GenericParam
   Lifetime lifetime;
   std::vector<Lifetime> lifetime_bounds;
   Attribute outer_attr;
-  Location locus;
+  location_t locus;
 
 public:
   Lifetime get_lifetime () const { return lifetime; }
@@ -1391,7 +1391,7 @@ public:
 
   // Constructor
   LifetimeParam (Lifetime lifetime, std::vector<Lifetime> lifetime_bounds,
-		 Attribute outer_attr, Location locus)
+		 Attribute outer_attr, location_t locus)
     : lifetime (std::move (lifetime)),
       lifetime_bounds (std::move (lifetime_bounds)),
       outer_attr (std::move (outer_attr)), locus (locus)
@@ -1418,7 +1418,7 @@ protected:
 class TraitItem : public Visitable
 {
 protected:
-  TraitItem (Location locus)
+  TraitItem (location_t locus)
     : node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus)
   {}
 
@@ -1426,7 +1426,7 @@ protected:
   virtual TraitItem *clone_trait_item_impl () const = 0;
 
   NodeId node_id;
-  Location locus;
+  location_t locus;
 
 public:
   virtual ~TraitItem () {}
diff --git a/gcc/rust/ast/rust-expr.h b/gcc/rust/ast/rust-expr.h
index 1ea82c7..c836250 100644
--- a/gcc/rust/ast/rust-expr.h
+++ b/gcc/rust/ast/rust-expr.h
@@ -39,7 +39,7 @@ class LiteralExpr : public ExprWithoutBlock
 {
   std::vector<Attribute> outer_attrs;
   Literal literal;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override { return literal.as_string (); }
@@ -48,13 +48,13 @@ public:
 
   LiteralExpr (std::string value_as_string, Literal::LitType type,
 	       PrimitiveCoreType type_hint, std::vector<Attribute> outer_attrs,
-	       Location locus)
+	       location_t locus)
     : outer_attrs (std::move (outer_attrs)),
       literal (std::move (value_as_string), type, type_hint), locus (locus)
   {}
 
   LiteralExpr (Literal literal, std::vector<Attribute> outer_attrs,
-	       Location locus)
+	       location_t locus)
     : outer_attrs (std::move (outer_attrs)), literal (std::move (literal)),
       locus (locus)
   {}
@@ -256,7 +256,7 @@ class OperatorExpr : public ExprWithoutBlock
 {
   // TODO: create binary and unary operator subclasses?
 public:
-  Location locus;
+  location_t locus;
 
 protected:
   /* Variables must be protected to allow derived classes to use them as first
@@ -266,7 +266,7 @@ protected:
 
   // Constructor (only for initialisation of expr purposes)
   OperatorExpr (std::unique_ptr<Expr> main_or_left_expr,
-		std::vector<Attribute> outer_attribs, Location locus)
+		std::vector<Attribute> outer_attribs, location_t locus)
     : locus (locus), outer_attrs (std::move (outer_attribs)),
       main_or_left_expr (std::move (main_or_left_expr))
   {}
@@ -331,7 +331,7 @@ public:
 
   BorrowExpr (std::unique_ptr<Expr> borrow_lvalue, bool is_mut_borrow,
 	      bool is_double_borrow, std::vector<Attribute> outer_attribs,
-	      Location locus)
+	      location_t locus)
     : OperatorExpr (std::move (borrow_lvalue), std::move (outer_attribs),
 		    locus),
       is_mut (is_mut_borrow), double_borrow (is_double_borrow)
@@ -367,7 +367,7 @@ public:
 
   // Constructor calls OperatorExpr's protected constructor
   DereferenceExpr (std::unique_ptr<Expr> deref_lvalue,
-		   std::vector<Attribute> outer_attribs, Location locus)
+		   std::vector<Attribute> outer_attribs, location_t locus)
     : OperatorExpr (std::move (deref_lvalue), std::move (outer_attribs), locus)
   {}
 
@@ -397,7 +397,7 @@ public:
 
   // Constructor calls OperatorExpr's protected constructor
   ErrorPropagationExpr (std::unique_ptr<Expr> potential_error_value,
-			std::vector<Attribute> outer_attribs, Location locus)
+			std::vector<Attribute> outer_attribs, location_t locus)
     : OperatorExpr (std::move (potential_error_value),
 		    std::move (outer_attribs), locus)
   {}
@@ -439,7 +439,7 @@ public:
 
   // Constructor calls OperatorExpr's protected constructor
   NegationExpr (std::unique_ptr<Expr> negated_value, ExprType expr_kind,
-		std::vector<Attribute> outer_attribs, Location locus)
+		std::vector<Attribute> outer_attribs, location_t locus)
     : OperatorExpr (std::move (negated_value), std::move (outer_attribs),
 		    locus),
       expr_type (expr_kind)
@@ -483,7 +483,7 @@ public:
   // Constructor calls OperatorExpr's protected constructor
   ArithmeticOrLogicalExpr (std::unique_ptr<Expr> left_value,
 			   std::unique_ptr<Expr> right_value,
-			   ExprType expr_kind, Location locus)
+			   ExprType expr_kind, location_t locus)
     : OperatorExpr (std::move (left_value), std::vector<Attribute> (), locus),
       expr_type (expr_kind), right_expr (std::move (right_value))
   {}
@@ -559,7 +559,7 @@ public:
   // Constructor requires pointers for polymorphism
   ComparisonExpr (std::unique_ptr<Expr> left_value,
 		  std::unique_ptr<Expr> right_value, ExprType comparison_kind,
-		  Location locus)
+		  location_t locus)
     : OperatorExpr (std::move (left_value), std::vector<Attribute> (), locus),
       expr_type (comparison_kind), right_expr (std::move (right_value))
   {}
@@ -631,7 +631,7 @@ public:
   // Constructor calls OperatorExpr's protected constructor
   LazyBooleanExpr (std::unique_ptr<Expr> left_bool_expr,
 		   std::unique_ptr<Expr> right_bool_expr, ExprType expr_kind,
-		   Location locus)
+		   location_t locus)
     : OperatorExpr (std::move (left_bool_expr), std::vector<Attribute> (),
 		    locus),
       expr_type (expr_kind), right_expr (std::move (right_bool_expr))
@@ -701,7 +701,7 @@ public:
 
   // Constructor requires calling protected constructor of OperatorExpr
   TypeCastExpr (std::unique_ptr<Expr> expr_to_cast,
-		std::unique_ptr<TypeNoBounds> type_to_cast_to, Location locus)
+		std::unique_ptr<TypeNoBounds> type_to_cast_to, location_t locus)
     : OperatorExpr (std::move (expr_to_cast), std::vector<Attribute> (), locus),
       type_to_convert_to (std::move (type_to_cast_to))
   {}
@@ -763,7 +763,7 @@ public:
   // Call OperatorExpr constructor to initialise left_expr
   AssignmentExpr (std::unique_ptr<Expr> value_to_assign_to,
 		  std::unique_ptr<Expr> value_to_assign,
-		  std::vector<Attribute> outer_attribs, Location locus)
+		  std::vector<Attribute> outer_attribs, location_t locus)
     : OperatorExpr (std::move (value_to_assign_to), std::move (outer_attribs),
 		    locus),
       right_expr (std::move (value_to_assign))
@@ -838,7 +838,7 @@ public:
   // Use pointers in constructor to enable polymorphism
   CompoundAssignmentExpr (std::unique_ptr<Expr> value_to_assign_to,
 			  std::unique_ptr<Expr> value_to_assign,
-			  ExprType expr_kind, Location locus)
+			  ExprType expr_kind, location_t locus)
     : OperatorExpr (std::move (value_to_assign_to), std::vector<Attribute> (),
 		    locus),
       expr_type (expr_kind), right_expr (std::move (value_to_assign))
@@ -898,7 +898,7 @@ class GroupedExpr : public ExprWithoutBlock
   std::vector<Attribute> outer_attrs;
   std::vector<Attribute> inner_attrs;
   std::unique_ptr<Expr> expr_in_parens;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
@@ -916,7 +916,7 @@ public:
 
   GroupedExpr (std::unique_ptr<Expr> parenthesised_expr,
 	       std::vector<Attribute> inner_attribs,
-	       std::vector<Attribute> outer_attribs, Location locus)
+	       std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)),
       inner_attrs (std::move (inner_attribs)),
       expr_in_parens (std::move (parenthesised_expr)), locus (locus)
@@ -1012,10 +1012,10 @@ protected:
 class ArrayElemsValues : public ArrayElems
 {
   std::vector<std::unique_ptr<Expr> > values;
-  Location locus;
+  location_t locus;
 
 public:
-  ArrayElemsValues (std::vector<std::unique_ptr<Expr> > elems, Location locus)
+  ArrayElemsValues (std::vector<std::unique_ptr<Expr> > elems, location_t locus)
     : ArrayElems (), values (std::move (elems)), locus (locus)
   {}
 
@@ -1066,12 +1066,12 @@ class ArrayElemsCopied : public ArrayElems
 {
   std::unique_ptr<Expr> elem_to_copy;
   std::unique_ptr<Expr> num_copies;
-  Location locus;
+  location_t locus;
 
 public:
   // Constructor requires pointers for polymorphism
   ArrayElemsCopied (std::unique_ptr<Expr> copied_elem,
-		    std::unique_ptr<Expr> copy_amount, Location locus)
+		    std::unique_ptr<Expr> copy_amount, location_t locus)
     : ArrayElems (), elem_to_copy (std::move (copied_elem)),
       num_copies (std::move (copy_amount)), locus (locus)
   {}
@@ -1126,7 +1126,7 @@ class ArrayExpr : public ExprWithoutBlock
   std::vector<Attribute> outer_attrs;
   std::vector<Attribute> inner_attrs;
   std::unique_ptr<ArrayElems> internal_elements;
-  Location locus;
+  location_t locus;
 
   // TODO: find another way to store this to save memory?
   bool marked_for_strip = false;
@@ -1148,7 +1148,7 @@ public:
   // Constructor requires ArrayElems pointer
   ArrayExpr (std::unique_ptr<ArrayElems> array_elems,
 	     std::vector<Attribute> inner_attribs,
-	     std::vector<Attribute> outer_attribs, Location locus)
+	     std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)),
       inner_attrs (std::move (inner_attribs)),
       internal_elements (std::move (array_elems)), locus (locus)
@@ -1219,14 +1219,14 @@ class ArrayIndexExpr : public ExprWithoutBlock
   std::vector<Attribute> outer_attrs;
   std::unique_ptr<Expr> array_expr;
   std::unique_ptr<Expr> index_expr;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
 
   ArrayIndexExpr (std::unique_ptr<Expr> array_expr,
 		  std::unique_ptr<Expr> array_index_expr,
-		  std::vector<Attribute> outer_attribs, Location locus)
+		  std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)),
       array_expr (std::move (array_expr)),
       index_expr (std::move (array_index_expr)), locus (locus)
@@ -1320,7 +1320,7 @@ class TupleExpr : public ExprWithoutBlock
   std::vector<Attribute> outer_attrs;
   std::vector<Attribute> inner_attrs;
   std::vector<std::unique_ptr<Expr> > tuple_elems;
-  Location locus;
+  location_t locus;
 
   // TODO: find another way to store this to save memory?
   bool marked_for_strip = false;
@@ -1341,7 +1341,7 @@ public:
 
   TupleExpr (std::vector<std::unique_ptr<Expr> > tuple_elements,
 	     std::vector<Attribute> inner_attribs,
-	     std::vector<Attribute> outer_attribs, Location locus)
+	     std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)),
       inner_attrs (std::move (inner_attribs)),
       tuple_elems (std::move (tuple_elements)), locus (locus)
@@ -1419,7 +1419,7 @@ class TupleIndexExpr : public ExprWithoutBlock
   // TupleIndex is a decimal int literal with no underscores or suffix
   TupleIndex tuple_index;
 
-  Location locus;
+  location_t locus;
 
   // i.e. pair.0
 
@@ -1429,7 +1429,7 @@ public:
   TupleIndex get_tuple_index () const { return tuple_index; }
 
   TupleIndexExpr (std::unique_ptr<Expr> tuple_expr, TupleIndex index,
-		  std::vector<Attribute> outer_attribs, Location locus)
+		  std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)),
       tuple_expr (std::move (tuple_expr)), tuple_index (index), locus (locus)
   {}
@@ -1538,7 +1538,7 @@ class StructExprStruct : public StructExpr
 {
   std::vector<Attribute> inner_attrs;
 
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
@@ -1549,7 +1549,7 @@ public:
   // Constructor has to call protected constructor of base class
   StructExprStruct (PathInExpression struct_path,
 		    std::vector<Attribute> inner_attribs,
-		    std::vector<Attribute> outer_attribs, Location locus)
+		    std::vector<Attribute> outer_attribs, location_t locus)
     : StructExpr (std::move (struct_path), std::move (outer_attribs)),
       inner_attrs (std::move (inner_attribs)), locus (locus)
   {}
@@ -1573,10 +1573,10 @@ struct StructBase
 {
 private:
   std::unique_ptr<Expr> base_struct;
-  Location locus;
+  location_t locus;
 
 public:
-  StructBase (std::unique_ptr<Expr> base_struct_ptr, Location locus)
+  StructBase (std::unique_ptr<Expr> base_struct_ptr, location_t locus)
     : base_struct (std::move (base_struct_ptr)), locus (locus)
   {}
 
@@ -1659,10 +1659,10 @@ protected:
 class StructExprFieldIdentifier : public StructExprField
 {
   Identifier field_name;
-  Location locus;
+  location_t locus;
 
 public:
-  StructExprFieldIdentifier (Identifier field_identifier, Location locus)
+  StructExprFieldIdentifier (Identifier field_identifier, location_t locus)
     : StructExprField (), field_name (std::move (field_identifier)),
       locus (locus)
   {}
@@ -1727,12 +1727,12 @@ public:
 class StructExprFieldIdentifierValue : public StructExprFieldWithVal
 {
   Identifier field_name;
-  Location locus;
+  location_t locus;
 
 public:
   StructExprFieldIdentifierValue (Identifier field_identifier,
 				  std::unique_ptr<Expr> field_value,
-				  Location locus)
+				  location_t locus)
     : StructExprFieldWithVal (std::move (field_value)),
       field_name (std::move (field_identifier)), locus (locus)
   {}
@@ -1758,11 +1758,12 @@ protected:
 class StructExprFieldIndexValue : public StructExprFieldWithVal
 {
   TupleIndex index;
-  Location locus;
+  location_t locus;
 
 public:
   StructExprFieldIndexValue (TupleIndex tuple_index,
-			     std::unique_ptr<Expr> field_value, Location locus)
+			     std::unique_ptr<Expr> field_value,
+			     location_t locus)
     : StructExprFieldWithVal (std::move (field_value)), index (tuple_index),
       locus (locus)
   {}
@@ -1801,8 +1802,8 @@ public:
   // Constructor for StructExprStructFields when no struct base is used
   StructExprStructFields (
     PathInExpression struct_path,
-    std::vector<std::unique_ptr<StructExprField> > expr_fields, Location locus,
-    StructBase base_struct = StructBase::error (),
+    std::vector<std::unique_ptr<StructExprField> > expr_fields,
+    location_t locus, StructBase base_struct = StructBase::error (),
     std::vector<Attribute> inner_attribs = std::vector<Attribute> (),
     std::vector<Attribute> outer_attribs = std::vector<Attribute> ())
     : StructExprStruct (std::move (struct_path), std::move (inner_attribs),
@@ -1872,7 +1873,7 @@ public:
 
   StructExprStructBase (PathInExpression struct_path, StructBase base_struct,
 			std::vector<Attribute> inner_attribs,
-			std::vector<Attribute> outer_attribs, Location locus)
+			std::vector<Attribute> outer_attribs, location_t locus)
     : StructExprStruct (std::move (struct_path), std::move (inner_attribs),
 			std::move (outer_attribs), locus),
       struct_base (std::move (base_struct))
@@ -1901,7 +1902,7 @@ class CallExpr : public ExprWithoutBlock
   std::vector<Attribute> outer_attrs;
   std::unique_ptr<Expr> function;
   std::vector<std::unique_ptr<Expr> > params;
-  Location locus;
+  location_t locus;
 
 public:
   Function *fndeclRef;
@@ -1910,7 +1911,7 @@ public:
 
   CallExpr (std::unique_ptr<Expr> function_expr,
 	    std::vector<std::unique_ptr<Expr> > function_params,
-	    std::vector<Attribute> outer_attribs, Location locus)
+	    std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)),
       function (std::move (function_expr)),
       params (std::move (function_params)), locus (locus)
@@ -2003,7 +2004,7 @@ class MethodCallExpr : public ExprWithoutBlock
   std::unique_ptr<Expr> receiver;
   PathExprSegment method_name;
   std::vector<std::unique_ptr<Expr> > params;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
@@ -2011,7 +2012,7 @@ public:
   MethodCallExpr (std::unique_ptr<Expr> call_receiver,
 		  PathExprSegment method_path,
 		  std::vector<std::unique_ptr<Expr> > method_params,
-		  std::vector<Attribute> outer_attribs, Location locus)
+		  std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)),
       receiver (std::move (call_receiver)),
       method_name (std::move (method_path)), params (std::move (method_params)),
@@ -2106,14 +2107,14 @@ class FieldAccessExpr : public ExprWithoutBlock
   std::vector<Attribute> outer_attrs;
   std::unique_ptr<Expr> receiver;
   Identifier field;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
 
   FieldAccessExpr (std::unique_ptr<Expr> field_access_receiver,
 		   Identifier field_name, std::vector<Attribute> outer_attribs,
-		   Location locus)
+		   location_t locus)
     : outer_attrs (std::move (outer_attribs)),
       receiver (std::move (field_access_receiver)),
       field (std::move (field_name)), locus (locus)
@@ -2191,7 +2192,7 @@ private:
   std::vector<Attribute> outer_attrs;
   std::unique_ptr<Pattern> pattern;
   std::unique_ptr<Type> type;
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether the type of the parameter has been given.
@@ -2200,7 +2201,7 @@ public:
   bool has_outer_attrs () const { return !outer_attrs.empty (); }
 
   // Constructor for closure parameter
-  ClosureParam (std::unique_ptr<Pattern> param_pattern, Location locus,
+  ClosureParam (std::unique_ptr<Pattern> param_pattern, location_t locus,
 		std::unique_ptr<Type> param_type = nullptr,
 		std::vector<Attribute> outer_attrs = {})
     : outer_attrs (std::move (outer_attrs)),
@@ -2277,11 +2278,11 @@ class ClosureExpr : public ExprWithoutBlock
   std::vector<Attribute> outer_attrs;
   bool has_move;
   std::vector<ClosureParam> params; // may be empty
-  Location locus;
+  location_t locus;
 
 protected:
   ClosureExpr (std::vector<ClosureParam> closure_params, bool has_move,
-	       std::vector<Attribute> outer_attribs, Location locus)
+	       std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)), has_move (has_move),
       params (std::move (closure_params)), locus (locus)
   {}
@@ -2316,7 +2317,7 @@ public:
 
   // Constructor for a ClosureExprInner
   ClosureExprInner (std::unique_ptr<Expr> closure_inner_expr,
-		    std::vector<ClosureParam> closure_params, Location locus,
+		    std::vector<ClosureParam> closure_params, location_t locus,
 		    bool is_move = false,
 		    std::vector<Attribute> outer_attribs
 		    = std::vector<Attribute> ())
@@ -2544,7 +2545,7 @@ public:
   ClosureExprInnerTyped (std::unique_ptr<Type> closure_return_type,
 			 std::unique_ptr<BlockExpr> closure_expr,
 			 std::vector<ClosureParam> closure_params,
-			 Location locus, bool is_move = false,
+			 location_t locus, bool is_move = false,
 			 std::vector<Attribute> outer_attribs
 			 = std::vector<Attribute> ())
     : ClosureExpr (std::move (closure_params), is_move,
@@ -2624,7 +2625,7 @@ class ContinueExpr : public ExprWithoutBlock
 {
   std::vector<Attribute> outer_attrs;
   Lifetime label;
-  Location locus;
+  location_t locus;
 
   // TODO: find another way to store this to save memory?
   bool marked_for_strip = false;
@@ -2637,7 +2638,7 @@ public:
 
   // Constructor for a ContinueExpr with a label.
   ContinueExpr (Lifetime label, std::vector<Attribute> outer_attribs,
-		Location locus)
+		location_t locus)
     : outer_attrs (std::move (outer_attribs)), label (std::move (label)),
       locus (locus)
   {}
@@ -2676,7 +2677,7 @@ class BreakExpr : public ExprWithoutBlock
   std::vector<Attribute> outer_attrs;
   Lifetime label;
   std::unique_ptr<Expr> break_expr;
-  Location locus;
+  location_t locus;
 
   // TODO: find another way to store this to save memory?
   bool marked_for_strip = false;
@@ -2693,7 +2694,7 @@ public:
 
   // Constructor for a break expression
   BreakExpr (Lifetime break_label, std::unique_ptr<Expr> expr_in_break,
-	     std::vector<Attribute> outer_attribs, Location locus)
+	     std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)), label (std::move (break_label)),
       break_expr (std::move (expr_in_break)), locus (locus)
   {}
@@ -2768,11 +2769,11 @@ protected:
 // Base range expression AST node object - abstract
 class RangeExpr : public ExprWithoutBlock
 {
-  Location locus;
+  location_t locus;
 
 protected:
   // outer attributes not allowed before range expressions
-  RangeExpr (Location locus) : locus (locus) {}
+  RangeExpr (location_t locus) : locus (locus) {}
 
 public:
   Location get_locus () const override final { return locus; }
@@ -2801,7 +2802,7 @@ public:
   std::string as_string () const override;
 
   RangeFromToExpr (std::unique_ptr<Expr> range_from,
-		   std::unique_ptr<Expr> range_to, Location locus)
+		   std::unique_ptr<Expr> range_to, location_t locus)
     : RangeExpr (locus), from (std::move (range_from)),
       to (std::move (range_to))
   {}
@@ -2883,7 +2884,7 @@ class RangeFromExpr : public RangeExpr
 public:
   std::string as_string () const override;
 
-  RangeFromExpr (std::unique_ptr<Expr> range_from, Location locus)
+  RangeFromExpr (std::unique_ptr<Expr> range_from, location_t locus)
     : RangeExpr (locus), from (std::move (range_from))
   {}
 
@@ -2945,7 +2946,7 @@ public:
   std::string as_string () const override;
 
   // outer attributes not allowed
-  RangeToExpr (std::unique_ptr<Expr> range_to, Location locus)
+  RangeToExpr (std::unique_ptr<Expr> range_to, location_t locus)
     : RangeExpr (locus), to (std::move (range_to))
   {}
 
@@ -3007,7 +3008,7 @@ class RangeFullExpr : public RangeExpr
 public:
   std::string as_string () const override;
 
-  RangeFullExpr (Location locus) : RangeExpr (locus) {}
+  RangeFullExpr (location_t locus) : RangeExpr (locus) {}
   // outer attributes not allowed
 
   void accept_vis (ASTVisitor &vis) override;
@@ -3036,7 +3037,7 @@ public:
   std::string as_string () const override;
 
   RangeFromToInclExpr (std::unique_ptr<Expr> range_from,
-		       std::unique_ptr<Expr> range_to, Location locus)
+		       std::unique_ptr<Expr> range_to, location_t locus)
     : RangeExpr (locus), from (std::move (range_from)),
       to (std::move (range_to))
   {}
@@ -3119,7 +3120,7 @@ class RangeToInclExpr : public RangeExpr
 public:
   std::string as_string () const override;
 
-  RangeToInclExpr (std::unique_ptr<Expr> range_to, Location locus)
+  RangeToInclExpr (std::unique_ptr<Expr> range_to, location_t locus)
     : RangeExpr (locus), to (std::move (range_to))
   {}
   // outer attributes not allowed
@@ -3177,7 +3178,7 @@ class ReturnExpr : public ExprWithoutBlock
 {
   std::vector<Attribute> outer_attrs;
   std::unique_ptr<Expr> return_expr;
-  Location locus;
+  location_t locus;
 
   // TODO: find another way to store this to save memory?
   bool marked_for_strip = false;
@@ -3191,7 +3192,7 @@ public:
 
   // Constructor for ReturnExpr.
   ReturnExpr (std::unique_ptr<Expr> returned_expr,
-	      std::vector<Attribute> outer_attribs, Location locus)
+	      std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)),
       return_expr (std::move (returned_expr)), locus (locus)
   {}
@@ -3268,13 +3269,13 @@ class UnsafeBlockExpr : public ExprWithBlock
   std::vector<Attribute> outer_attrs;
   // Or just have it extend BlockExpr
   std::unique_ptr<BlockExpr> expr;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
 
   UnsafeBlockExpr (std::unique_ptr<BlockExpr> block_expr,
-		   std::vector<Attribute> outer_attribs, Location locus)
+		   std::vector<Attribute> outer_attribs, location_t locus)
     : outer_attrs (std::move (outer_attribs)), expr (std::move (block_expr)),
       locus (locus)
   {}
@@ -3346,14 +3347,14 @@ protected:
 class LoopLabel /*: public Node*/
 {
   Lifetime label; // or type LIFETIME_OR_LABEL
-  Location locus;
+  location_t locus;
 
   NodeId node_id;
 
 public:
   std::string as_string () const;
 
-  LoopLabel (Lifetime loop_label, Location locus = UNDEF_LOCATION)
+  LoopLabel (Lifetime loop_label, location_t locus = UNDEF_LOCATION)
     : label (std::move (loop_label)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
@@ -3381,11 +3382,11 @@ protected:
   std::unique_ptr<BlockExpr> loop_block;
 
 private:
-  Location locus;
+  location_t locus;
 
 protected:
   // Constructor for BaseLoopExpr
-  BaseLoopExpr (std::unique_ptr<BlockExpr> loop_block, Location locus,
+  BaseLoopExpr (std::unique_ptr<BlockExpr> loop_block, location_t locus,
 		LoopLabel loop_label = LoopLabel::error (),
 		std::vector<Attribute> outer_attribs
 		= std::vector<Attribute> ())
@@ -3459,7 +3460,7 @@ public:
   std::string as_string () const override;
 
   // Constructor for LoopExpr
-  LoopExpr (std::unique_ptr<BlockExpr> loop_block, Location locus,
+  LoopExpr (std::unique_ptr<BlockExpr> loop_block, location_t locus,
 	    LoopLabel loop_label = LoopLabel::error (),
 	    std::vector<Attribute> outer_attribs = std::vector<Attribute> ())
     : BaseLoopExpr (std::move (loop_block), locus, std::move (loop_label),
@@ -3487,7 +3488,7 @@ public:
 
   // Constructor for while loop with loop label
   WhileLoopExpr (std::unique_ptr<Expr> loop_condition,
-		 std::unique_ptr<BlockExpr> loop_block, Location locus,
+		 std::unique_ptr<BlockExpr> loop_block, location_t locus,
 		 LoopLabel loop_label = LoopLabel::error (),
 		 std::vector<Attribute> outer_attribs
 		 = std::vector<Attribute> ())
@@ -3548,7 +3549,7 @@ public:
   // Constructor with a loop label
   WhileLetLoopExpr (std::vector<std::unique_ptr<Pattern> > match_arm_patterns,
 		    std::unique_ptr<Expr> scrutinee,
-		    std::unique_ptr<BlockExpr> loop_block, Location locus,
+		    std::unique_ptr<BlockExpr> loop_block, location_t locus,
 		    LoopLabel loop_label = LoopLabel::error (),
 		    std::vector<Attribute> outer_attribs
 		    = std::vector<Attribute> ())
@@ -3630,7 +3631,7 @@ public:
   // Constructor with loop label
   ForLoopExpr (std::unique_ptr<Pattern> loop_pattern,
 	       std::unique_ptr<Expr> iterator_expr,
-	       std::unique_ptr<BlockExpr> loop_body, Location locus,
+	       std::unique_ptr<BlockExpr> loop_body, location_t locus,
 	       LoopLabel loop_label = LoopLabel::error (),
 	       std::vector<Attribute> outer_attribs = std::vector<Attribute> ())
     : BaseLoopExpr (std::move (loop_body), locus, std::move (loop_label),
@@ -3696,13 +3697,13 @@ class IfExpr : public ExprWithBlock
   std::vector<Attribute> outer_attrs;
   std::unique_ptr<Expr> condition;
   std::unique_ptr<BlockExpr> if_block;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
 
   IfExpr (std::unique_ptr<Expr> condition, std::unique_ptr<BlockExpr> if_block,
-	  std::vector<Attribute> outer_attrs, Location locus)
+	  std::vector<Attribute> outer_attrs, location_t locus)
     : outer_attrs (std::move (outer_attrs)), condition (std::move (condition)),
       if_block (std::move (if_block)), locus (locus)
   {}
@@ -3818,7 +3819,7 @@ public:
   IfExprConseqElse (std::unique_ptr<Expr> condition,
 		    std::unique_ptr<BlockExpr> if_block,
 		    std::unique_ptr<ExprWithBlock> else_block,
-		    std::vector<Attribute> outer_attrs, Location locus)
+		    std::vector<Attribute> outer_attrs, location_t locus)
     : IfExpr (std::move (condition), std::move (if_block),
 	      std::move (outer_attrs), locus),
       else_block (std::move (else_block))
@@ -3872,14 +3873,14 @@ class IfLetExpr : public ExprWithBlock
   std::vector<std::unique_ptr<Pattern> > match_arm_patterns; // inlined
   std::unique_ptr<Expr> value;
   std::unique_ptr<BlockExpr> if_block;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
 
   IfLetExpr (std::vector<std::unique_ptr<Pattern> > match_arm_patterns,
 	     std::unique_ptr<Expr> value, std::unique_ptr<BlockExpr> if_block,
-	     std::vector<Attribute> outer_attrs, Location locus)
+	     std::vector<Attribute> outer_attrs, location_t locus)
     : outer_attrs (std::move (outer_attrs)),
       match_arm_patterns (std::move (match_arm_patterns)),
       value (std::move (value)), if_block (std::move (if_block)), locus (locus)
@@ -4011,7 +4012,7 @@ public:
     std::vector<std::unique_ptr<Pattern> > match_arm_patterns,
     std::unique_ptr<Expr> value, std::unique_ptr<BlockExpr> if_block,
     std::unique_ptr<ExprWithBlock> else_block,
-    std::vector<Attribute> outer_attrs, Location locus)
+    std::vector<Attribute> outer_attrs, location_t locus)
     : IfLetExpr (std::move (match_arm_patterns), std::move (value),
 		 std::move (if_block), std::move (outer_attrs), locus),
       else_block (std::move (else_block))
@@ -4070,7 +4071,7 @@ private:
   // inlined from MatchArmGuard
   std::unique_ptr<Expr> guard_expr;
 
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether the MatchArm has a match arm guard expression
@@ -4078,7 +4079,7 @@ public:
 
   // Constructor for match arm with a guard expression
   MatchArm (std::vector<std::unique_ptr<Pattern> > match_arm_patterns,
-	    Location locus, std::unique_ptr<Expr> guard_expr = nullptr,
+	    location_t locus, std::unique_ptr<Expr> guard_expr = nullptr,
 	    std::vector<Attribute> outer_attrs = std::vector<Attribute> ())
     : outer_attrs (std::move (outer_attrs)),
       match_arm_patterns (std::move (match_arm_patterns)),
@@ -4128,7 +4129,7 @@ public:
   // Creates a match arm in an error state.
   static MatchArm create_error ()
   {
-    Location locus = UNDEF_LOCATION;
+    location_t locus = UNDEF_LOCATION;
     return MatchArm (std::vector<std::unique_ptr<Pattern> > (), locus);
   }
 
@@ -4219,7 +4220,7 @@ class MatchExpr : public ExprWithBlock
   std::unique_ptr<Expr> branch_value;
   std::vector<Attribute> inner_attrs;
   std::vector<MatchCase> match_arms;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
@@ -4230,7 +4231,7 @@ public:
   MatchExpr (std::unique_ptr<Expr> branch_value,
 	     std::vector<MatchCase> match_arms,
 	     std::vector<Attribute> inner_attrs,
-	     std::vector<Attribute> outer_attrs, Location locus)
+	     std::vector<Attribute> outer_attrs, location_t locus)
     : outer_attrs (std::move (outer_attrs)),
       branch_value (std::move (branch_value)),
       inner_attrs (std::move (inner_attrs)),
@@ -4314,12 +4315,12 @@ class AwaitExpr : public ExprWithoutBlock
 {
   std::vector<Attribute> outer_attrs;
   std::unique_ptr<Expr> awaited_expr;
-  Location locus;
+  location_t locus;
 
 public:
   // TODO: ensure outer attributes are actually allowed
   AwaitExpr (std::unique_ptr<Expr> awaited_expr,
-	     std::vector<Attribute> outer_attrs, Location locus)
+	     std::vector<Attribute> outer_attrs, location_t locus)
     : outer_attrs (std::move (outer_attrs)),
       awaited_expr (std::move (awaited_expr)), locus (locus)
   {}
@@ -4395,11 +4396,11 @@ class AsyncBlockExpr : public ExprWithBlock
   std::vector<Attribute> outer_attrs;
   bool has_move;
   std::unique_ptr<BlockExpr> block_expr;
-  Location locus;
+  location_t locus;
 
 public:
   AsyncBlockExpr (std::unique_ptr<BlockExpr> block_expr, bool has_move,
-		  std::vector<Attribute> outer_attrs, Location locus)
+		  std::vector<Attribute> outer_attrs, location_t locus)
     : outer_attrs (std::move (outer_attrs)), has_move (has_move),
       block_expr (std::move (block_expr)), locus (locus)
   {}
@@ -4509,7 +4510,7 @@ struct InlineAsmRegOrRegClass
   };
 
   Identifier name;
-  Location locus;
+  location_t locus;
 };
 
 struct InlineAsmOperand
@@ -4561,14 +4562,14 @@ struct InlineAsmOperand
   {
     std::unique_ptr<Expr> sym;
   };
-  Location locus;
+  location_t locus;
 };
 
 struct InlineAsmPlaceHolder
 {
   size_t operand_idx;
   char modifier; // can be null
-  Location locus;
+  location_t locus;
 };
 
 struct InlineAsmTemplatePiece
diff --git a/gcc/rust/ast/rust-item.h b/gcc/rust/ast/rust-item.h
index 8ddfb1d..d385798 100644
--- a/gcc/rust/ast/rust-item.h
+++ b/gcc/rust/ast/rust-item.h
@@ -63,7 +63,7 @@ class TypeParam : public GenericParam
   // bool has_type;
   std::unique_ptr<Type> type;
 
-  Location locus;
+  location_t locus;
 
 public:
   Identifier get_type_representation () const { return type_representation; }
@@ -77,7 +77,7 @@ public:
   // Returns whether the type param has an outer attribute.
   bool has_outer_attribute () const { return !outer_attr.is_empty (); }
 
-  TypeParam (Identifier type_representation, Location locus = UNDEF_LOCATION,
+  TypeParam (Identifier type_representation, location_t locus = UNDEF_LOCATION,
 	     std::vector<std::unique_ptr<TypeParamBound>> type_param_bounds
 	     = std::vector<std::unique_ptr<TypeParamBound>> (),
 	     std::unique_ptr<Type> type = nullptr,
@@ -191,13 +191,13 @@ class LifetimeWhereClauseItem : public WhereClauseItem
 {
   Lifetime lifetime;
   std::vector<Lifetime> lifetime_bounds;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
   LifetimeWhereClauseItem (Lifetime lifetime,
 			   std::vector<Lifetime> lifetime_bounds,
-			   Location locus)
+			   location_t locus)
     : lifetime (std::move (lifetime)),
       lifetime_bounds (std::move (lifetime_bounds)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
@@ -230,7 +230,7 @@ class TypeBoundWhereClauseItem : public WhereClauseItem
   std::unique_ptr<Type> bound_type;
   std::vector<std::unique_ptr<TypeParamBound>> type_param_bounds;
   NodeId node_id;
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether the item has ForLifetimes
@@ -244,7 +244,7 @@ public:
   TypeBoundWhereClauseItem (
     std::vector<LifetimeParam> for_lifetimes, std::unique_ptr<Type> bound_type,
     std::vector<std::unique_ptr<TypeParamBound>> type_param_bounds,
-    Location locus)
+    location_t locus)
     : for_lifetimes (std::move (for_lifetimes)),
       bound_type (std::move (bound_type)),
       type_param_bounds (std::move (type_param_bounds)),
@@ -387,7 +387,7 @@ class SelfParam
 
   NodeId node_id;
 
-  Location locus;
+  location_t locus;
 
   // Unrestricted constructor used for error state
   SelfParam (Lifetime lifetime, bool has_ref, bool is_mut, Type *type)
@@ -420,14 +420,14 @@ public:
   }
 
   // Type-based self parameter (not ref, no lifetime)
-  SelfParam (std::unique_ptr<Type> type, bool is_mut, Location locus)
+  SelfParam (std::unique_ptr<Type> type, bool is_mut, location_t locus)
     : has_ref (false), is_mut (is_mut), lifetime (Lifetime::error ()),
       type (std::move (type)),
       node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus)
   {}
 
   // Lifetime-based self parameter (is ref, no type)
-  SelfParam (Lifetime lifetime, bool is_mut, Location locus)
+  SelfParam (Lifetime lifetime, bool is_mut, location_t locus)
     : has_ref (true), is_mut (is_mut), lifetime (std::move (lifetime)),
       node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus)
   {}
@@ -490,10 +490,10 @@ class FunctionQualifiers
   bool has_unsafe;
   bool has_extern;
   std::string extern_abi;
-  Location locus;
+  location_t locus;
 
 public:
-  FunctionQualifiers (Location locus, AsyncConstStatus const_status,
+  FunctionQualifiers (location_t locus, AsyncConstStatus const_status,
 		      bool has_unsafe, bool has_extern = false,
 		      std::string extern_abi = std::string ())
     : const_status (const_status), has_unsafe (has_unsafe),
@@ -522,14 +522,14 @@ public:
 class FunctionParam
 {
   std::vector<Attribute> outer_attrs;
-  Location locus;
+  location_t locus;
   std::unique_ptr<Pattern> param_name;
   std::unique_ptr<Type> type;
 
 public:
   FunctionParam (std::unique_ptr<Pattern> param_name,
 		 std::unique_ptr<Type> param_type,
-		 std::vector<Attribute> outer_attrs, Location locus)
+		 std::vector<Attribute> outer_attrs, location_t locus)
     : outer_attrs (std::move (outer_attrs)), locus (locus),
       param_name (std::move (param_name)), type (std::move (param_type)),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
@@ -623,13 +623,13 @@ private:
   VisType vis_type;
   // Only assigned if vis_type is IN_PATH
   SimplePath in_path;
-  Location locus;
+  location_t locus;
 
   // should this store location info?
 
 public:
   // Creates a Visibility - TODO make constructor protected or private?
-  Visibility (VisType vis_type, SimplePath in_path, Location locus)
+  Visibility (VisType vis_type, SimplePath in_path, location_t locus)
     : vis_type (vis_type), in_path (std::move (in_path)), locus (locus)
   {}
 
@@ -738,7 +738,7 @@ class Method : public InherentImplItem, public TraitImplItem
   std::unique_ptr<Type> return_type;
   WhereClause where_clause;
   std::unique_ptr<BlockExpr> function_body;
-  Location locus;
+  location_t locus;
   NodeId node_id;
   bool is_default;
 
@@ -781,7 +781,7 @@ public:
 	  SelfParam self_param, std::vector<FunctionParam> function_params,
 	  std::unique_ptr<Type> return_type, WhereClause where_clause,
 	  std::unique_ptr<BlockExpr> function_body, Visibility vis,
-	  std::vector<Attribute> outer_attrs, Location locus,
+	  std::vector<Attribute> outer_attrs, location_t locus,
 	  bool is_default = false)
     : outer_attrs (std::move (outer_attrs)), vis (std::move (vis)),
       qualifiers (std::move (qualifiers)),
@@ -1008,7 +1008,7 @@ public:
 
 private:
   Identifier module_name;
-  Location locus;
+  location_t locus;
   ModuleKind kind;
 
   // Name of the file including the module
@@ -1040,7 +1040,7 @@ public:
 
   // Unloaded module constructor
   Module (Identifier module_name, Visibility visibility,
-	  std::vector<Attribute> outer_attrs, Location locus,
+	  std::vector<Attribute> outer_attrs, location_t locus,
 	  std::string outer_filename, std::vector<std::string> module_scope)
     : VisItem (std::move (visibility), std::move (outer_attrs)),
       module_name (module_name), locus (locus), kind (ModuleKind::UNLOADED),
@@ -1050,7 +1050,7 @@ public:
   {}
 
   // Loaded module constructor, with items
-  Module (Identifier name, Location locus,
+  Module (Identifier name, location_t locus,
 	  std::vector<std::unique_ptr<Item>> items,
 	  Visibility visibility = Visibility::create_error (),
 	  std::vector<Attribute> inner_attrs = std::vector<Attribute> (),
@@ -1156,7 +1156,7 @@ class ExternCrate : public VisItem
   // this is either an identifier or "_", with _ parsed to string
   std::string as_clause_name;
 
-  Location locus;
+  location_t locus;
 
   /* e.g.
       "extern crate foo as _"
@@ -1174,7 +1174,7 @@ public:
 
   // Constructor
   ExternCrate (std::string referenced_crate, Visibility visibility,
-	       std::vector<Attribute> outer_attrs, Location locus,
+	       std::vector<Attribute> outer_attrs, location_t locus,
 	       std::string as_clause_name = std::string ())
     : VisItem (std::move (visibility), std::move (outer_attrs)),
       referenced_crate (std::move (referenced_crate)),
@@ -1213,7 +1213,7 @@ protected:
 // The path-ish thing referred to in a use declaration - abstract base class
 class UseTree
 {
-  Location locus;
+  location_t locus;
 
 public:
   enum Kind
@@ -1256,7 +1256,7 @@ protected:
   // Clone function implementation as pure virtual method
   virtual UseTree *clone_use_tree_impl () const = 0;
 
-  UseTree (Location locus) : locus (locus) {}
+  UseTree (location_t locus) : locus (locus) {}
 };
 
 // Use tree with a glob (wildcard) operator
@@ -1275,7 +1275,7 @@ private:
   SimplePath path;
 
 public:
-  UseTreeGlob (PathType glob_type, SimplePath path, Location locus)
+  UseTreeGlob (PathType glob_type, SimplePath path, location_t locus)
     : UseTree (locus), glob_type (glob_type), path (std::move (path))
   {
     if (this->glob_type != PATH_PREFIXED)
@@ -1336,7 +1336,7 @@ private:
 
 public:
   UseTreeList (PathType path_type, SimplePath path,
-	       std::vector<std::unique_ptr<UseTree>> trees, Location locus)
+	       std::vector<std::unique_ptr<UseTree>> trees, location_t locus)
     : UseTree (locus), path_type (path_type), path (std::move (path)),
       trees (std::move (trees))
   {
@@ -1432,7 +1432,7 @@ private:
   Identifier identifier; // only if NewBindType is IDENTIFIER
 
 public:
-  UseTreeRebind (NewBindType bind_type, SimplePath path, Location locus,
+  UseTreeRebind (NewBindType bind_type, SimplePath path, location_t locus,
 		 Identifier identifier = std::string ())
     : UseTree (locus), path (std::move (path)), bind_type (bind_type),
       identifier (std::move (identifier))
@@ -1479,13 +1479,13 @@ protected:
 class UseDeclaration : public VisItem
 {
   std::unique_ptr<UseTree> use_tree;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
 
   UseDeclaration (std::unique_ptr<UseTree> use_tree, Visibility visibility,
-		  std::vector<Attribute> outer_attrs, Location locus)
+		  std::vector<Attribute> outer_attrs, location_t locus)
     : VisItem (std::move (visibility), std::move (outer_attrs)),
       use_tree (std::move (use_tree)), locus (locus)
   {}
@@ -1553,7 +1553,7 @@ class Function : public VisItem, public InherentImplItem, public TraitImplItem
   std::unique_ptr<Type> return_type;
   WhereClause where_clause;
   std::unique_ptr<BlockExpr> function_body;
-  Location locus;
+  location_t locus;
   bool is_default;
 
 public:
@@ -1577,7 +1577,7 @@ public:
 	    std::vector<FunctionParam> function_params,
 	    std::unique_ptr<Type> return_type, WhereClause where_clause,
 	    std::unique_ptr<BlockExpr> function_body, Visibility vis,
-	    std::vector<Attribute> outer_attrs, Location locus,
+	    std::vector<Attribute> outer_attrs, location_t locus,
 	    bool is_default = false)
     : VisItem (std::move (vis), std::move (outer_attrs)),
       qualifiers (std::move (qualifiers)),
@@ -1730,7 +1730,7 @@ class TypeAlias : public VisItem, public TraitImplItem
 
   std::unique_ptr<Type> existing_type;
 
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
@@ -1745,7 +1745,8 @@ public:
   TypeAlias (Identifier new_type_name,
 	     std::vector<std::unique_ptr<GenericParam>> generic_params,
 	     WhereClause where_clause, std::unique_ptr<Type> existing_type,
-	     Visibility vis, std::vector<Attribute> outer_attrs, Location locus)
+	     Visibility vis, std::vector<Attribute> outer_attrs,
+	     location_t locus)
     : VisItem (std::move (vis), std::move (outer_attrs)),
       new_type_name (std::move (new_type_name)),
       generic_params (std::move (generic_params)),
@@ -1854,7 +1855,7 @@ protected:
   WhereClause where_clause;
 
 private:
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether struct has generic parameters.
@@ -1888,7 +1889,7 @@ public:
 protected:
   Struct (Identifier struct_name,
 	  std::vector<std::unique_ptr<GenericParam>> generic_params,
-	  WhereClause where_clause, Visibility vis, Location locus,
+	  WhereClause where_clause, Visibility vis, location_t locus,
 	  std::vector<Attribute> outer_attrs = std::vector<Attribute> ())
     : VisItem (std::move (vis), std::move (outer_attrs)),
       struct_name (std::move (struct_name)),
@@ -1940,7 +1941,7 @@ class StructField
 
   NodeId node_id;
 
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether struct field has any outer attributes.
@@ -1950,7 +1951,7 @@ public:
   bool has_visibility () const { return !visibility.is_error (); }
 
   StructField (Identifier field_name, std::unique_ptr<Type> field_type,
-	       Visibility vis, Location locus,
+	       Visibility vis, location_t locus,
 	       std::vector<Attribute> outer_attrs = std::vector<Attribute> ())
     : outer_attrs (std::move (outer_attrs)), visibility (std::move (vis)),
       field_name (std::move (field_name)), field_type (std::move (field_type)),
@@ -2041,7 +2042,7 @@ public:
   StructStruct (std::vector<StructField> fields, Identifier struct_name,
 		std::vector<std::unique_ptr<GenericParam>> generic_params,
 		WhereClause where_clause, bool is_unit, Visibility vis,
-		std::vector<Attribute> outer_attrs, Location locus)
+		std::vector<Attribute> outer_attrs, location_t locus)
     : Struct (std::move (struct_name), std::move (generic_params),
 	      std::move (where_clause), std::move (vis), locus,
 	      std::move (outer_attrs)),
@@ -2052,7 +2053,7 @@ public:
   StructStruct (Identifier struct_name,
 		std::vector<std::unique_ptr<GenericParam>> generic_params,
 		WhereClause where_clause, Visibility vis,
-		std::vector<Attribute> outer_attrs, Location locus)
+		std::vector<Attribute> outer_attrs, location_t locus)
     : Struct (std::move (struct_name), std::move (generic_params),
 	      std::move (where_clause), std::move (vis), locus,
 	      std::move (outer_attrs)),
@@ -2092,7 +2093,7 @@ class TupleField
 
   NodeId node_id;
 
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether tuple field has outer attributes.
@@ -2103,7 +2104,8 @@ public:
   bool has_visibility () const { return !visibility.is_error (); }
 
   // Complete constructor
-  TupleField (std::unique_ptr<Type> field_type, Visibility vis, Location locus,
+  TupleField (std::unique_ptr<Type> field_type, Visibility vis,
+	      location_t locus,
 	      std::vector<Attribute> outer_attrs = std::vector<Attribute> ())
     : outer_attrs (std::move (outer_attrs)), visibility (std::move (vis)),
       field_type (std::move (field_type)),
@@ -2185,7 +2187,7 @@ public:
   TupleStruct (std::vector<TupleField> fields, Identifier struct_name,
 	       std::vector<std::unique_ptr<GenericParam>> generic_params,
 	       WhereClause where_clause, Visibility vis,
-	       std::vector<Attribute> outer_attrs, Location locus)
+	       std::vector<Attribute> outer_attrs, location_t locus)
     : Struct (std::move (struct_name), std::move (generic_params),
 	      std::move (where_clause), std::move (vis), locus,
 	      std::move (outer_attrs)),
@@ -2214,13 +2216,13 @@ class EnumItem : public VisItem
 {
   Identifier variant_name;
 
-  Location locus;
+  location_t locus;
 
 public:
   virtual ~EnumItem () {}
 
   EnumItem (Identifier variant_name, Visibility vis,
-	    std::vector<Attribute> outer_attrs, Location locus)
+	    std::vector<Attribute> outer_attrs, location_t locus)
     : VisItem (std::move (vis), std::move (outer_attrs)),
       variant_name (std::move (variant_name)), locus (locus)
   {}
@@ -2260,7 +2262,7 @@ public:
 
   EnumItemTuple (Identifier variant_name, Visibility vis,
 		 std::vector<TupleField> tuple_fields,
-		 std::vector<Attribute> outer_attrs, Location locus)
+		 std::vector<Attribute> outer_attrs, location_t locus)
     : EnumItem (std::move (variant_name), std::move (vis),
 		std::move (outer_attrs), locus),
       tuple_fields (std::move (tuple_fields))
@@ -2297,7 +2299,7 @@ public:
 
   EnumItemStruct (Identifier variant_name, Visibility vis,
 		  std::vector<StructField> struct_fields,
-		  std::vector<Attribute> outer_attrs, Location locus)
+		  std::vector<Attribute> outer_attrs, location_t locus)
     : EnumItem (std::move (variant_name), std::move (vis),
 		std::move (outer_attrs), locus),
       struct_fields (std::move (struct_fields))
@@ -2330,7 +2332,7 @@ class EnumItemDiscriminant : public EnumItem
 public:
   EnumItemDiscriminant (Identifier variant_name, Visibility vis,
 			std::unique_ptr<Expr> expr,
-			std::vector<Attribute> outer_attrs, Location locus)
+			std::vector<Attribute> outer_attrs, location_t locus)
     : EnumItem (std::move (variant_name), std::move (vis),
 		std::move (outer_attrs), locus),
       expression (std::move (expr))
@@ -2389,7 +2391,7 @@ class Enum : public VisItem
 
   std::vector<std::unique_ptr<EnumItem>> items;
 
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
@@ -2408,7 +2410,7 @@ public:
   Enum (Identifier enum_name, Visibility vis,
 	std::vector<std::unique_ptr<GenericParam>> generic_params,
 	WhereClause where_clause, std::vector<std::unique_ptr<EnumItem>> items,
-	std::vector<Attribute> outer_attrs, Location locus)
+	std::vector<Attribute> outer_attrs, location_t locus)
     : VisItem (std::move (vis), std::move (outer_attrs)),
       enum_name (std::move (enum_name)),
       generic_params (std::move (generic_params)),
@@ -2504,7 +2506,7 @@ class Union : public VisItem
 
   std::vector<StructField> variants;
 
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
@@ -2518,7 +2520,7 @@ public:
   Union (Identifier union_name, Visibility vis,
 	 std::vector<std::unique_ptr<GenericParam>> generic_params,
 	 WhereClause where_clause, std::vector<StructField> variants,
-	 std::vector<Attribute> outer_attrs, Location locus)
+	 std::vector<Attribute> outer_attrs, location_t locus)
     : VisItem (std::move (vis), std::move (outer_attrs)),
       union_name (std::move (union_name)),
       generic_params (std::move (generic_params)),
@@ -2603,14 +2605,14 @@ class ConstantItem : public VisItem,
   std::unique_ptr<Type> type;
   std::unique_ptr<Expr> const_expr;
 
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
 
   ConstantItem (std::string ident, Visibility vis, std::unique_ptr<Type> type,
 		std::unique_ptr<Expr> const_expr,
-		std::vector<Attribute> outer_attrs, Location locus)
+		std::vector<Attribute> outer_attrs, location_t locus)
     : VisItem (std::move (vis), std::move (outer_attrs)),
       identifier (std::move (ident)), type (std::move (type)),
       const_expr (std::move (const_expr)), locus (locus)
@@ -2718,14 +2720,14 @@ class StaticItem : public VisItem
   Identifier name;
   std::unique_ptr<Type> type;
   std::unique_ptr<Expr> expr;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
 
   StaticItem (Identifier name, bool is_mut, std::unique_ptr<Type> type,
 	      std::unique_ptr<Expr> expr, Visibility vis,
-	      std::vector<Attribute> outer_attrs, Location locus)
+	      std::vector<Attribute> outer_attrs, location_t locus)
     : VisItem (std::move (vis), std::move (outer_attrs)), has_mut (is_mut),
       name (std::move (name)), type (std::move (type)), expr (std::move (expr)),
       locus (locus)
@@ -2948,7 +2950,7 @@ public:
   bool has_definition () const { return block_expr != nullptr; }
 
   TraitItemFunc (TraitFunctionDecl decl, std::unique_ptr<BlockExpr> block_expr,
-		 std::vector<Attribute> outer_attrs, Location locus)
+		 std::vector<Attribute> outer_attrs, location_t locus)
     : TraitItem (locus), outer_attrs (std::move (outer_attrs)),
       decl (std::move (decl)), block_expr (std::move (block_expr))
   {}
@@ -3164,7 +3166,7 @@ public:
   bool has_definition () const { return block_expr != nullptr; }
 
   TraitItemMethod (TraitMethodDecl decl, std::unique_ptr<BlockExpr> block_expr,
-		   std::vector<Attribute> outer_attrs, Location locus)
+		   std::vector<Attribute> outer_attrs, location_t locus)
     : TraitItem (locus), outer_attrs (std::move (outer_attrs)),
       decl (std::move (decl)), block_expr (std::move (block_expr))
   {}
@@ -3252,7 +3254,7 @@ public:
 
   TraitItemConst (Identifier name, std::unique_ptr<Type> type,
 		  std::unique_ptr<Expr> expr,
-		  std::vector<Attribute> outer_attrs, Location locus)
+		  std::vector<Attribute> outer_attrs, location_t locus)
     : TraitItem (locus), outer_attrs (std::move (outer_attrs)),
       name (std::move (name)), type (std::move (type)), expr (std::move (expr))
   {}
@@ -3359,7 +3361,7 @@ public:
 
   TraitItemType (Identifier name,
 		 std::vector<std::unique_ptr<TypeParamBound>> type_param_bounds,
-		 std::vector<Attribute> outer_attrs, Location locus)
+		 std::vector<Attribute> outer_attrs, location_t locus)
     : TraitItem (locus), outer_attrs (std::move (outer_attrs)),
       name (std::move (name)), type_param_bounds (std::move (type_param_bounds))
   {}
@@ -3439,7 +3441,7 @@ class Trait : public VisItem
   WhereClause where_clause;
   std::vector<Attribute> inner_attrs;
   std::vector<std::unique_ptr<TraitItem>> trait_items;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
@@ -3471,7 +3473,7 @@ public:
 	 WhereClause where_clause,
 	 std::vector<std::unique_ptr<TraitItem>> trait_items, Visibility vis,
 	 std::vector<Attribute> outer_attrs, std::vector<Attribute> inner_attrs,
-	 Location locus)
+	 location_t locus)
     : VisItem (std::move (vis), std::move (outer_attrs)),
       has_unsafe (is_unsafe), has_auto (is_auto), name (std::move (name)),
       generic_params (std::move (generic_params)),
@@ -3611,7 +3613,7 @@ protected:
 
 private:
   // doesn't really need to be protected as write access probably not needed
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether impl has generic parameters.
@@ -3657,7 +3659,7 @@ protected:
   Impl (std::vector<std::unique_ptr<GenericParam>> generic_params,
 	std::unique_ptr<Type> trait_type, WhereClause where_clause,
 	Visibility vis, std::vector<Attribute> inner_attrs,
-	std::vector<Attribute> outer_attrs, Location locus)
+	std::vector<Attribute> outer_attrs, location_t locus)
     : VisItem (std::move (vis), std::move (outer_attrs)),
       generic_params (std::move (generic_params)),
       trait_type (std::move (trait_type)),
@@ -3722,7 +3724,7 @@ public:
 		std::vector<std::unique_ptr<GenericParam>> generic_params,
 		std::unique_ptr<Type> trait_type, WhereClause where_clause,
 		Visibility vis, std::vector<Attribute> inner_attrs,
-		std::vector<Attribute> outer_attrs, Location locus)
+		std::vector<Attribute> outer_attrs, location_t locus)
     : Impl (std::move (generic_params), std::move (trait_type),
 	    std::move (where_clause), std::move (vis), std::move (inner_attrs),
 	    std::move (outer_attrs), locus),
@@ -3796,7 +3798,7 @@ public:
 	     std::vector<std::unique_ptr<GenericParam>> generic_params,
 	     std::unique_ptr<Type> trait_type, WhereClause where_clause,
 	     Visibility vis, std::vector<Attribute> inner_attrs,
-	     std::vector<Attribute> outer_attrs, Location locus)
+	     std::vector<Attribute> outer_attrs, location_t locus)
     : Impl (std::move (generic_params), std::move (trait_type),
 	    std::move (where_clause), std::move (vis), std::move (inner_attrs),
 	    std::move (outer_attrs), locus),
@@ -3872,7 +3874,7 @@ class ExternalItem
   Visibility visibility;
 
   Identifier item_name;
-  Location locus;
+  location_t locus;
 
 public:
   virtual ~ExternalItem () {}
@@ -3906,7 +3908,7 @@ public:
 
 protected:
   ExternalItem (Identifier item_name, Visibility vis,
-		std::vector<Attribute> outer_attrs, Location locus)
+		std::vector<Attribute> outer_attrs, location_t locus)
     : outer_attrs (std::move (outer_attrs)), visibility (std::move (vis)),
       item_name (std::move (item_name)), locus (locus)
   {}
@@ -3948,13 +3950,13 @@ class ExternalTypeItem : public ExternalItem
 
   Visibility visibility;
   Identifier item_name;
-  Location locus;
+  location_t locus;
 
   bool marked_for_strip;
 
 public:
   ExternalTypeItem (Identifier item_name, Visibility vis,
-		    std::vector<Attribute> outer_attrs, Location locus)
+		    std::vector<Attribute> outer_attrs, location_t locus)
     : ExternalItem (), outer_attrs (std::move (outer_attrs)), visibility (vis),
       item_name (std::move (item_name)), locus (locus), marked_for_strip (false)
   {}
@@ -4026,7 +4028,7 @@ class ExternalStaticItem : public ExternalItem
   Visibility visibility;
 
   Identifier item_name;
-  Location locus;
+  location_t locus;
 
   bool has_mut;
   std::unique_ptr<Type> item_type;
@@ -4034,7 +4036,7 @@ class ExternalStaticItem : public ExternalItem
 public:
   ExternalStaticItem (Identifier item_name, std::unique_ptr<Type> item_type,
 		      bool is_mut, Visibility vis,
-		      std::vector<Attribute> outer_attrs, Location locus)
+		      std::vector<Attribute> outer_attrs, location_t locus)
     : ExternalItem (), outer_attrs (std::move (outer_attrs)),
       visibility (std::move (vis)), item_name (std::move (item_name)),
       locus (locus), has_mut (is_mut), item_type (std::move (item_type))
@@ -4130,7 +4132,7 @@ class NamedFunctionParam
   std::vector<Attribute> outer_attrs;
 
   NodeId node_id;
-  Location locus;
+  location_t locus;
 
 public:
   /* Returns whether the named function parameter has a name (i.e. name is not
@@ -4157,7 +4159,7 @@ public:
   }
 
   NamedFunctionParam (std::string name, std::unique_ptr<Type> param_type,
-		      std::vector<Attribute> outer_attrs, Location locus)
+		      std::vector<Attribute> outer_attrs, location_t locus)
     : name (std::move (name)), param_type (std::move (param_type)),
       outer_attrs (std::move (outer_attrs)),
       node_id (Analysis::Mappings::get ()->get_next_node_id ()), locus (locus)
@@ -4226,7 +4228,7 @@ class ExternalFunctionItem : public ExternalItem
   Visibility visibility;
 
   Identifier item_name;
-  Location locus;
+  location_t locus;
 
   // bool has_generics;
   // Generics generic_params;
@@ -4279,7 +4281,7 @@ public:
     std::unique_ptr<Type> return_type, WhereClause where_clause,
     std::vector<NamedFunctionParam> function_params, bool has_variadics,
     std::vector<Attribute> variadic_outer_attrs, Visibility vis,
-    std::vector<Attribute> outer_attrs, Location locus)
+    std::vector<Attribute> outer_attrs, location_t locus)
     : ExternalItem (), outer_attrs (std::move (outer_attrs)),
       visibility (std::move (vis)), item_name (std::move (item_name)),
       locus (locus), generic_params (std::move (generic_params)),
@@ -4405,7 +4407,7 @@ class ExternBlock : public VisItem
   // bool has_extern_items;
   std::vector<std::unique_ptr<ExternalItem>> extern_items;
 
-  Location locus;
+  location_t locus;
 
   // TODO: find another way to store this to save memory?
   bool marked_for_strip = false;
@@ -4427,7 +4429,7 @@ public:
   ExternBlock (std::string abi,
 	       std::vector<std::unique_ptr<ExternalItem>> extern_items,
 	       Visibility vis, std::vector<Attribute> inner_attrs,
-	       std::vector<Attribute> outer_attrs, Location locus)
+	       std::vector<Attribute> outer_attrs, location_t locus)
     : VisItem (std::move (vis), std::move (outer_attrs)), abi (std::move (abi)),
       inner_attrs (std::move (inner_attrs)),
       extern_items (std::move (extern_items)), locus (locus)
diff --git a/gcc/rust/ast/rust-macro.h b/gcc/rust/ast/rust-macro.h
index 55fbd3a..b416208 100644
--- a/gcc/rust/ast/rust-macro.h
+++ b/gcc/rust/ast/rust-macro.h
@@ -167,10 +167,11 @@ class MacroMatchFragment : public MacroMatch
 {
   Identifier ident;
   MacroFragSpec frag_spec;
-  Location locus;
+  location_t locus;
 
 public:
-  MacroMatchFragment (Identifier ident, MacroFragSpec frag_spec, Location locus)
+  MacroMatchFragment (Identifier ident, MacroFragSpec frag_spec,
+		      location_t locus)
     : ident (std::move (ident)), frag_spec (frag_spec), locus (locus)
   {}
 
@@ -181,7 +182,7 @@ public:
   }
 
   // Creates an error state macro match fragment.
-  static MacroMatchFragment create_error (Location locus)
+  static MacroMatchFragment create_error (location_t locus)
   {
     return MacroMatchFragment (std::string (""),
 			       MacroFragSpec (MacroFragSpec::Kind::INVALID),
@@ -230,7 +231,7 @@ private:
   typedef Token MacroRepSep;
   // any token except delimiters and repetition operators
   std::unique_ptr<MacroRepSep> sep;
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether macro match repetition has separator token.
@@ -238,7 +239,7 @@ public:
 
   MacroMatchRepetition (std::vector<std::unique_ptr<MacroMatch>> matches,
 			MacroRepOp op, std::unique_ptr<MacroRepSep> sep,
-			Location locus)
+			location_t locus)
     : matches (std::move (matches)), op (op), sep (std::move (sep)),
       locus (locus)
   {}
@@ -311,7 +312,7 @@ class MacroMatcher : public MacroMatch
 {
   DelimType delim_type;
   std::vector<std::unique_ptr<MacroMatch>> matches;
-  Location locus;
+  location_t locus;
 
   // TODO: think of way to mark invalid that doesn't take up more space
   bool is_invalid;
@@ -319,7 +320,7 @@ class MacroMatcher : public MacroMatch
 public:
   MacroMatcher (DelimType delim_type,
 		std::vector<std::unique_ptr<MacroMatch>> matches,
-		Location locus)
+		location_t locus)
     : delim_type (delim_type), matches (std::move (matches)), locus (locus),
       is_invalid (false)
   {}
@@ -351,7 +352,7 @@ public:
   MacroMatcher &operator= (MacroMatcher &&other) = default;
 
   // Creates an error state macro matcher.
-  static MacroMatcher create_error (Location locus)
+  static MacroMatcher create_error (location_t locus)
   {
     return MacroMatcher (true, locus);
   }
@@ -385,7 +386,7 @@ protected:
   }
 
   // constructor only used to create error matcher
-  MacroMatcher (bool is_invalid, Location locus)
+  MacroMatcher (bool is_invalid, location_t locus)
     : delim_type (PARENS), locus (locus), is_invalid (is_invalid)
   {}
 };
@@ -395,10 +396,10 @@ struct MacroTranscriber
 {
 private:
   DelimTokenTree token_tree;
-  Location locus;
+  location_t locus;
 
 public:
-  MacroTranscriber (DelimTokenTree token_tree, Location locus)
+  MacroTranscriber (DelimTokenTree token_tree, location_t locus)
     : token_tree (std::move (token_tree)), locus (locus)
   {}
 
@@ -416,10 +417,11 @@ struct MacroRule
 private:
   MacroMatcher matcher;
   MacroTranscriber transcriber;
-  Location locus;
+  location_t locus;
 
 public:
-  MacroRule (MacroMatcher matcher, MacroTranscriber transcriber, Location locus)
+  MacroRule (MacroMatcher matcher, MacroTranscriber transcriber,
+	     location_t locus)
     : matcher (std::move (matcher)), transcriber (std::move (transcriber)),
       locus (locus)
   {}
@@ -428,7 +430,7 @@ public:
   bool is_error () const { return matcher.is_error (); }
 
   // Creates an error state macro rule.
-  static MacroRule create_error (Location locus)
+  static MacroRule create_error (location_t locus)
   {
     return MacroRule (MacroMatcher::create_error (locus),
 		      MacroTranscriber (DelimTokenTree::create_empty (),
@@ -464,7 +466,7 @@ private:
   DelimType delim_type;
   // MacroRules rules;
   std::vector<MacroRule> rules; // inlined form
-  Location locus;
+  location_t locus;
 
   std::function<Fragment (Location, MacroInvocData &)> associated_transcriber;
   // Since we can't compare std::functions, we need to use an extra boolean
@@ -491,7 +493,7 @@ private:
    * is "extremely self-referential and non-intuitive". */
   MacroRulesDefinition (Identifier rule_name, DelimType delim_type,
 			std::vector<MacroRule> rules,
-			std::vector<Attribute> outer_attrs, Location locus,
+			std::vector<Attribute> outer_attrs, location_t locus,
 			MacroKind kind, Visibility vis)
     : VisItem (std::move (vis), outer_attrs),
       outer_attrs (std::move (outer_attrs)), rule_name (std::move (rule_name)),
@@ -516,7 +518,7 @@ public:
 
   static std::unique_ptr<MacroRulesDefinition>
   mbe (Identifier rule_name, DelimType delim_type, std::vector<MacroRule> rules,
-       std::vector<Attribute> outer_attrs, Location locus)
+       std::vector<Attribute> outer_attrs, location_t locus)
   {
     return Rust::make_unique<MacroRulesDefinition> (
       MacroRulesDefinition (rule_name, delim_type, rules, outer_attrs, locus,
@@ -526,7 +528,7 @@ public:
 
   static std::unique_ptr<MacroRulesDefinition>
   decl_macro (Identifier rule_name, std::vector<MacroRule> rules,
-	      std::vector<Attribute> outer_attrs, Location locus,
+	      std::vector<Attribute> outer_attrs, location_t locus,
 	      Visibility vis)
   {
     return Rust::make_unique<MacroRulesDefinition> (MacroRulesDefinition (
@@ -619,7 +621,7 @@ public:
    */
   static std::unique_ptr<MacroInvocation>
   Regular (MacroInvocData invoc_data, std::vector<Attribute> outer_attrs,
-	   Location locus, bool is_semi_coloned = false)
+	   location_t locus, bool is_semi_coloned = false)
   {
     return std::unique_ptr<MacroInvocation> (
       new MacroInvocation (InvocKind::Regular, tl::nullopt, invoc_data,
@@ -633,7 +635,7 @@ public:
    */
   static std::unique_ptr<MacroInvocation> Builtin (
     BuiltinMacro kind, MacroInvocData invoc_data,
-    std::vector<Attribute> outer_attrs, Location locus,
+    std::vector<Attribute> outer_attrs, location_t locus,
     std::vector<std::unique_ptr<MacroInvocation>> &&pending_eager_invocations
     = {},
     bool is_semi_coloned = false)
@@ -711,7 +713,7 @@ private:
   MacroInvocation (
     InvocKind kind, tl::optional<BuiltinMacro> builtin_kind,
     MacroInvocData invoc_data, std::vector<Attribute> outer_attrs,
-    Location locus, bool is_semi_coloned,
+    location_t locus, bool is_semi_coloned,
     std::vector<std::unique_ptr<MacroInvocation>> &&pending_eager_invocs)
     : TraitItem (locus), outer_attrs (std::move (outer_attrs)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ()),
@@ -733,7 +735,7 @@ private:
   }
 
   std::vector<Attribute> outer_attrs;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
   /* The data given to the macro invocation */
diff --git a/gcc/rust/ast/rust-path.cc b/gcc/rust/ast/rust-path.cc
index 7c6d7e1..431480c 100644
--- a/gcc/rust/ast/rust-path.cc
+++ b/gcc/rust/ast/rust-path.cc
@@ -172,7 +172,7 @@ PathPattern::convert_to_simple_path (bool with_opening_scope_resolution) const
     }
 
   // kind of a HACK to get locus depending on opening scope resolution
-  Location locus = UNKNOWN_LOCATION;
+  location_t locus = UNKNOWN_LOCATION;
   if (with_opening_scope_resolution)
     locus = simple_segments[0].get_locus () - 2; // minus 2 chars for ::
   else
diff --git a/gcc/rust/ast/rust-path.h b/gcc/rust/ast/rust-path.h
index 5675fda..7f14a3f 100644
--- a/gcc/rust/ast/rust-path.h
+++ b/gcc/rust/ast/rust-path.h
@@ -31,11 +31,11 @@ namespace AST {
 class PathIdentSegment
 {
   std::string segment_name;
-  Location locus;
+  location_t locus;
 
   // only allow identifiers, "super", "self", "Self", "crate", or "$crate"
 public:
-  PathIdentSegment (std::string segment_name, Location locus)
+  PathIdentSegment (std::string segment_name, location_t locus)
     : segment_name (std::move (segment_name)), locus (locus)
   {}
 
@@ -64,7 +64,7 @@ struct GenericArgsBinding
 private:
   Identifier identifier;
   std::unique_ptr<Type> type;
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether binding is in an error state.
@@ -82,7 +82,7 @@ public:
 
   // Pointer type for type in constructor to enable polymorphism
   GenericArgsBinding (Identifier ident, std::unique_ptr<Type> type_ptr,
-		      Location locus = UNDEF_LOCATION)
+		      location_t locus = UNDEF_LOCATION)
     : identifier (std::move (ident)), type (std::move (type_ptr)), locus (locus)
   {}
 
@@ -175,7 +175,7 @@ public:
     return GenericArg (nullptr, std::move (type), {""}, Kind::Type, locus);
   }
 
-  static GenericArg create_ambiguous (Identifier path, Location locus)
+  static GenericArg create_ambiguous (Identifier path, location_t locus)
   {
     return GenericArg (nullptr, nullptr, std::move (path), Kind::Either, locus);
   }
@@ -280,7 +280,7 @@ public:
 
 private:
   GenericArg (std::unique_ptr<Expr> expression, std::unique_ptr<Type> type,
-	      Identifier path, Kind kind, Location locus)
+	      Identifier path, Kind kind, location_t locus)
     : expression (std::move (expression)), type (std::move (type)),
       path (std::move (path)), kind (kind), locus (locus)
   {}
@@ -308,7 +308,7 @@ private:
   /* Which kind of const generic application are we dealing with */
   Kind kind;
 
-  Location locus;
+  location_t locus;
 };
 
 /**
@@ -328,12 +328,12 @@ class ConstGenericParam : public GenericParam
   GenericArg default_value;
 
   Attribute outer_attr;
-  Location locus;
+  location_t locus;
 
 public:
   ConstGenericParam (Identifier name, std::unique_ptr<AST::Type> type,
 		     GenericArg default_value, Attribute outer_attr,
-		     Location locus)
+		     location_t locus)
     : name (name), type (std::move (type)),
       default_value (std::move (default_value)), outer_attr (outer_attr),
       locus (locus)
@@ -394,7 +394,7 @@ struct GenericArgs
   std::vector<Lifetime> lifetime_args;
   std::vector<GenericArg> generic_args;
   std::vector<GenericArgsBinding> binding_args;
-  Location locus;
+  location_t locus;
 
 public:
   // Returns true if there are any generic arguments
@@ -407,7 +407,7 @@ public:
   GenericArgs (std::vector<Lifetime> lifetime_args,
 	       std::vector<GenericArg> generic_args,
 	       std::vector<GenericArgsBinding> binding_args,
-	       Location locus = UNDEF_LOCATION)
+	       location_t locus = UNDEF_LOCATION)
     : lifetime_args (std::move (lifetime_args)),
       generic_args (std::move (generic_args)),
       binding_args (std::move (binding_args)), locus (locus)
@@ -472,7 +472,7 @@ class PathExprSegment
 private:
   PathIdentSegment segment_name;
   GenericArgs generic_args;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
@@ -480,7 +480,7 @@ public:
   bool has_generic_args () const { return generic_args.has_generic_args (); }
 
   // Constructor for segment (from IdentSegment and GenericArgs)
-  PathExprSegment (PathIdentSegment segment_name, Location locus,
+  PathExprSegment (PathIdentSegment segment_name, location_t locus,
 		   GenericArgs generic_args = GenericArgs::create_empty ())
     : segment_name (std::move (segment_name)),
       generic_args (std::move (generic_args)), locus (locus),
@@ -489,7 +489,7 @@ public:
 
   /* Constructor for segment with generic arguments (from segment name and all
    * args) */
-  PathExprSegment (std::string segment_name, Location locus,
+  PathExprSegment (std::string segment_name, location_t locus,
 		   std::vector<Lifetime> lifetime_args = {},
 		   std::vector<GenericArg> generic_args = {},
 		   std::vector<GenericArgsBinding> binding_args = {})
@@ -583,7 +583,7 @@ class PathInExpression : public PathPattern, public PathExpr
 {
   std::vector<Attribute> outer_attrs;
   bool has_opening_scope_resolution;
-  Location locus;
+  location_t locus;
   NodeId _node_id;
 
 public:
@@ -591,7 +591,7 @@ public:
 
   // Constructor
   PathInExpression (std::vector<PathExprSegment> path_segments,
-		    std::vector<Attribute> outer_attrs, Location locus,
+		    std::vector<Attribute> outer_attrs, location_t locus,
 		    bool has_opening_scope_resolution = false)
     : PathPattern (std::move (path_segments)),
       outer_attrs (std::move (outer_attrs)),
@@ -681,7 +681,7 @@ public:
 
 private:
   PathIdentSegment ident_segment;
-  Location locus;
+  location_t locus;
 
 protected:
   /* This is protected because it is only really used by derived classes, not
@@ -709,14 +709,14 @@ public:
   }
 
   TypePathSegment (PathIdentSegment ident_segment,
-		   bool has_separating_scope_resolution, Location locus)
+		   bool has_separating_scope_resolution, location_t locus)
     : ident_segment (std::move (ident_segment)), locus (locus),
       has_separating_scope_resolution (has_separating_scope_resolution),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
 
   TypePathSegment (std::string segment_name,
-		   bool has_separating_scope_resolution, Location locus)
+		   bool has_separating_scope_resolution, location_t locus)
     : ident_segment (PathIdentSegment (std::move (segment_name), locus)),
       locus (locus),
       has_separating_scope_resolution (has_separating_scope_resolution),
@@ -797,7 +797,7 @@ public:
   // Constructor with PathIdentSegment and GenericArgs
   TypePathSegmentGeneric (PathIdentSegment ident_segment,
 			  bool has_separating_scope_resolution,
-			  GenericArgs generic_args, Location locus)
+			  GenericArgs generic_args, location_t locus)
     : TypePathSegment (std::move (ident_segment),
 		       has_separating_scope_resolution, locus),
       generic_args (std::move (generic_args))
@@ -809,7 +809,7 @@ public:
 			  std::vector<Lifetime> lifetime_args,
 			  std::vector<GenericArg> generic_args,
 			  std::vector<GenericArgsBinding> binding_args,
-			  Location locus)
+			  location_t locus)
     : TypePathSegment (std::move (segment_name),
 		       has_separating_scope_resolution, locus),
       generic_args (GenericArgs (std::move (lifetime_args),
@@ -868,11 +868,11 @@ private:
   // FIXME: think of better way to mark as invalid than taking up storage
   bool is_invalid;
 
-  Location locus;
+  location_t locus;
 
 protected:
   // Constructor only used to create invalid type path functions.
-  TypePathFunction (bool is_invalid, Location locus)
+  TypePathFunction (bool is_invalid, location_t locus)
     : is_invalid (is_invalid), locus (locus)
   {}
 
@@ -893,8 +893,8 @@ public:
   }
 
   // Constructor
-  TypePathFunction (std::vector<std::unique_ptr<Type> > inputs, Location locus,
-		    std::unique_ptr<Type> type = nullptr)
+  TypePathFunction (std::vector<std::unique_ptr<Type> > inputs,
+		    location_t locus, std::unique_ptr<Type> type = nullptr)
     : inputs (std::move (inputs)), return_type (std::move (type)),
       is_invalid (false), locus (locus)
   {}
@@ -966,7 +966,7 @@ public:
   // Constructor with PathIdentSegment and TypePathFn
   TypePathSegmentFunction (PathIdentSegment ident_segment,
 			   bool has_separating_scope_resolution,
-			   TypePathFunction function_path, Location locus)
+			   TypePathFunction function_path, location_t locus)
     : TypePathSegment (std::move (ident_segment),
 		       has_separating_scope_resolution, locus),
       function_path (std::move (function_path))
@@ -975,7 +975,7 @@ public:
   // Constructor with segment name and TypePathFn
   TypePathSegmentFunction (std::string segment_name,
 			   bool has_separating_scope_resolution,
-			   TypePathFunction function_path, Location locus)
+			   TypePathFunction function_path, location_t locus)
     : TypePathSegment (std::move (segment_name),
 		       has_separating_scope_resolution, locus),
       function_path (std::move (function_path))
@@ -1006,7 +1006,7 @@ class TypePath : public TypeNoBounds
 {
   bool has_opening_scope_resolution;
   std::vector<std::unique_ptr<TypePathSegment> > segments;
-  Location locus;
+  location_t locus;
 
 protected:
   /* Use covariance to implement clone function as returning this object
@@ -1036,7 +1036,7 @@ public:
 
   // Constructor
   TypePath (std::vector<std::unique_ptr<TypePathSegment> > segments,
-	    Location locus, bool has_opening_scope_resolution = false)
+	    location_t locus, bool has_opening_scope_resolution = false)
     : TypeNoBounds (),
       has_opening_scope_resolution (has_opening_scope_resolution),
       segments (std::move (segments)), locus (locus)
@@ -1102,13 +1102,13 @@ struct QualifiedPathType
 private:
   std::unique_ptr<Type> type_to_invoke_on;
   TypePath trait_path;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
   // Constructor
   QualifiedPathType (std::unique_ptr<Type> invoke_on_type,
-		     Location locus = UNDEF_LOCATION,
+		     location_t locus = UNDEF_LOCATION,
 		     TypePath trait_path = TypePath::create_error ())
     : type_to_invoke_on (std::move (invoke_on_type)),
       trait_path (std::move (trait_path)), locus (locus),
@@ -1187,7 +1187,7 @@ class QualifiedPathInExpression : public PathPattern, public PathExpr
 {
   std::vector<Attribute> outer_attrs;
   QualifiedPathType path_type;
-  Location locus;
+  location_t locus;
   NodeId _node_id;
 
 public:
@@ -1195,7 +1195,8 @@ public:
 
   QualifiedPathInExpression (QualifiedPathType qual_path_type,
 			     std::vector<PathExprSegment> path_segments,
-			     std::vector<Attribute> outer_attrs, Location locus)
+			     std::vector<Attribute> outer_attrs,
+			     location_t locus)
     : PathPattern (std::move (path_segments)),
       outer_attrs (std::move (outer_attrs)),
       path_type (std::move (qual_path_type)), locus (locus),
@@ -1275,7 +1276,7 @@ class QualifiedPathInType : public TypeNoBounds
   QualifiedPathType path_type;
   std::unique_ptr<TypePathSegment> associated_segment;
   std::vector<std::unique_ptr<TypePathSegment> > segments;
-  Location locus;
+  location_t locus;
 
 protected:
   /* Use covariance to implement clone function as returning this object
@@ -1290,7 +1291,7 @@ public:
     QualifiedPathType qual_path_type,
     std::unique_ptr<TypePathSegment> associated_segment,
     std::vector<std::unique_ptr<TypePathSegment> > path_segments,
-    Location locus)
+    location_t locus)
     : path_type (std::move (qual_path_type)),
       associated_segment (std::move (associated_segment)),
       segments (std::move (path_segments)), locus (locus)
diff --git a/gcc/rust/ast/rust-pattern.h b/gcc/rust/ast/rust-pattern.h
index 0fd3c06..d35fbce 100644
--- a/gcc/rust/ast/rust-pattern.h
+++ b/gcc/rust/ast/rust-pattern.h
@@ -27,19 +27,19 @@ namespace AST {
 class LiteralPattern : public Pattern
 {
   Literal lit;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
   std::string as_string () const override;
 
   // Constructor for a literal pattern
-  LiteralPattern (Literal lit, Location locus)
+  LiteralPattern (Literal lit, location_t locus)
     : lit (std::move (lit)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
 
-  LiteralPattern (std::string val, Literal::LitType type, Location locus,
+  LiteralPattern (std::string val, Literal::LitType type, location_t locus,
 		  PrimitiveCoreType type_hint)
     : lit (Literal (std::move (val), type, type_hint)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
@@ -75,7 +75,7 @@ class IdentifierPattern : public Pattern
 
   // bool has_pattern;
   std::unique_ptr<Pattern> to_bind;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
@@ -85,7 +85,7 @@ public:
   bool has_pattern_to_bind () const { return to_bind != nullptr; }
 
   // Constructor
-  IdentifierPattern (Identifier ident, Location locus, bool is_ref = false,
+  IdentifierPattern (Identifier ident, location_t locus, bool is_ref = false,
 		     bool is_mut = false,
 		     std::unique_ptr<Pattern> to_bind = nullptr)
     : Pattern (), variable_ident (std::move (ident)), is_ref (is_ref),
@@ -93,7 +93,7 @@ public:
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
 
-  IdentifierPattern (NodeId node_id, Identifier ident, Location locus,
+  IdentifierPattern (NodeId node_id, Identifier ident, location_t locus,
 		     bool is_ref = false, bool is_mut = false,
 		     std::unique_ptr<Pattern> to_bind = nullptr)
     : Pattern (), variable_ident (std::move (ident)), is_ref (is_ref),
@@ -165,13 +165,13 @@ protected:
 // AST node for using the '_' wildcard "match any value" pattern
 class WildcardPattern : public Pattern
 {
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
   std::string as_string () const override { return std::string (1, '_'); }
 
-  WildcardPattern (Location locus)
+  WildcardPattern (location_t locus)
     : locus (locus), node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
 
@@ -194,13 +194,13 @@ protected:
 
 class RestPattern : public Pattern
 {
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
   std::string as_string () const override { return ".."; }
 
-  RestPattern (Location locus)
+  RestPattern (location_t locus)
     : locus (locus), node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
 
@@ -258,11 +258,11 @@ class RangePatternBoundLiteral : public RangePatternBound
   // Minus prefixed to literal (if integer or floating-point)
   bool has_minus;
 
-  Location locus;
+  location_t locus;
 
 public:
   // Constructor
-  RangePatternBoundLiteral (Literal literal, Location locus,
+  RangePatternBoundLiteral (Literal literal, location_t locus,
 			    bool has_minus = false)
     : literal (literal), has_minus (has_minus), locus (locus)
   {}
@@ -373,7 +373,7 @@ class RangePattern : public Pattern
 
   /* location only stored to avoid a dereference - lower pattern should give
    * correct location so maybe change in future */
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
@@ -381,7 +381,7 @@ public:
 
   // Constructor
   RangePattern (std::unique_ptr<RangePatternBound> lower,
-		std::unique_ptr<RangePatternBound> upper, Location locus,
+		std::unique_ptr<RangePatternBound> upper, location_t locus,
 		bool has_ellipsis_syntax = false)
     : lower (std::move (lower)), upper (std::move (upper)),
       has_ellipsis_syntax (has_ellipsis_syntax), locus (locus),
@@ -454,14 +454,14 @@ class ReferencePattern : public Pattern
   bool has_two_amps;
   bool is_mut;
   std::unique_ptr<Pattern> pattern;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
   std::string as_string () const override;
 
   ReferencePattern (std::unique_ptr<Pattern> pattern, bool is_mut_reference,
-		    bool ref_has_two_amps, Location locus)
+		    bool ref_has_two_amps, location_t locus)
     : has_two_amps (ref_has_two_amps), is_mut (is_mut_reference),
       pattern (std::move (pattern)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
@@ -544,7 +544,7 @@ public:
 class StructPatternField
 {
   std::vector<Attribute> outer_attrs;
-  Location locus;
+  location_t locus;
 
 protected:
   NodeId node_id;
@@ -583,7 +583,7 @@ public:
   const std::vector<Attribute> &get_outer_attrs () const { return outer_attrs; }
 
 protected:
-  StructPatternField (std::vector<Attribute> outer_attribs, Location locus,
+  StructPatternField (std::vector<Attribute> outer_attribs, location_t locus,
 		      NodeId node_id)
     : outer_attrs (std::move (outer_attribs)), locus (locus), node_id (node_id)
   {}
@@ -602,7 +602,7 @@ public:
   StructPatternFieldTuplePat (TupleIndex index,
 			      std::unique_ptr<Pattern> tuple_pattern,
 			      std::vector<Attribute> outer_attribs,
-			      Location locus)
+			      location_t locus)
     : StructPatternField (std::move (outer_attribs), locus,
 			  Analysis::Mappings::get ()->get_next_node_id ()),
       index (index), tuple_pattern (std::move (tuple_pattern))
@@ -682,7 +682,7 @@ public:
   StructPatternFieldIdentPat (Identifier ident,
 			      std::unique_ptr<Pattern> ident_pattern,
 			      std::vector<Attribute> outer_attrs,
-			      Location locus)
+			      location_t locus)
     : StructPatternField (std::move (outer_attrs), locus,
 			  Analysis::Mappings::get ()->get_next_node_id ()),
       ident (std::move (ident)), ident_pattern (std::move (ident_pattern))
@@ -761,7 +761,7 @@ class StructPatternFieldIdent : public StructPatternField
 
 public:
   StructPatternFieldIdent (Identifier ident, bool is_ref, bool is_mut,
-			   std::vector<Attribute> outer_attrs, Location locus)
+			   std::vector<Attribute> outer_attrs, location_t locus)
     : StructPatternField (std::move (outer_attrs), locus,
 			  Analysis::Mappings::get ()->get_next_node_id ()),
       has_ref (is_ref), has_mut (is_mut), ident (std::move (ident))
@@ -908,13 +908,13 @@ class StructPattern : public Pattern
   StructPatternElements elems;
 
   NodeId node_id;
-  Location locus;
+  location_t locus;
 
 public:
   std::string as_string () const override;
 
   // Constructs a struct pattern from specified StructPatternElements
-  StructPattern (PathInExpression struct_path, Location locus,
+  StructPattern (PathInExpression struct_path, location_t locus,
 		 StructPatternElements elems
 		 = StructPatternElements::create_empty ())
     : path (std::move (struct_path)), elems (std::move (elems)),
@@ -1379,7 +1379,7 @@ class TuplePattern : public Pattern
 {
   // bool has_tuple_pattern_items;
   std::unique_ptr<TuplePatternItems> items;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
@@ -1388,7 +1388,7 @@ public:
   // Returns true if the tuple pattern has items
   bool has_tuple_pattern_items () const { return items != nullptr; }
 
-  TuplePattern (std::unique_ptr<TuplePatternItems> items, Location locus)
+  TuplePattern (std::unique_ptr<TuplePatternItems> items, location_t locus)
     : items (std::move (items)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
@@ -1445,7 +1445,7 @@ protected:
 class GroupedPattern : public Pattern
 {
   std::unique_ptr<Pattern> pattern_in_parens;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
@@ -1454,7 +1454,7 @@ public:
     return "(" + pattern_in_parens->as_string () + ")";
   }
 
-  GroupedPattern (std::unique_ptr<Pattern> pattern_in_parens, Location locus)
+  GroupedPattern (std::unique_ptr<Pattern> pattern_in_parens, location_t locus)
     : pattern_in_parens (std::move (pattern_in_parens)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
@@ -1507,13 +1507,13 @@ protected:
 class SlicePattern : public Pattern
 {
   std::vector<std::unique_ptr<Pattern>> items;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
   std::string as_string () const override;
 
-  SlicePattern (std::vector<std::unique_ptr<Pattern>> items, Location locus)
+  SlicePattern (std::vector<std::unique_ptr<Pattern>> items, location_t locus)
     : items (std::move (items)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
@@ -1574,13 +1574,13 @@ protected:
 class AltPattern : public Pattern
 {
   std::vector<std::unique_ptr<Pattern>> alts;
-  Location locus;
+  location_t locus;
   NodeId node_id;
 
 public:
   std::string as_string () const override;
 
-  AltPattern (std::vector<std::unique_ptr<Pattern>> alts, Location locus)
+  AltPattern (std::vector<std::unique_ptr<Pattern>> alts, location_t locus)
     : alts (std::move (alts)), locus (locus),
       node_id (Analysis::Mappings::get ()->get_next_node_id ())
   {}
diff --git a/gcc/rust/ast/rust-stmt.h b/gcc/rust/ast/rust-stmt.h
index 80395ab..e5b90b0 100644
--- a/gcc/rust/ast/rust-stmt.h
+++ b/gcc/rust/ast/rust-stmt.h
@@ -28,7 +28,7 @@ namespace AST {
 // Just a semi-colon, which apparently is a statement.
 class EmptyStmt : public Stmt
 {
-  Location locus;
+  location_t locus;
 
   // TODO: find another way to store this to save memory?
   bool marked_for_strip = false;
@@ -36,7 +36,7 @@ class EmptyStmt : public Stmt
 public:
   std::string as_string () const override { return std::string (1, ';'); }
 
-  EmptyStmt (Location locus) : locus (locus) {}
+  EmptyStmt (location_t locus) : locus (locus) {}
 
   Location get_locus () const override final { return locus; }
 
@@ -71,7 +71,7 @@ class LetStmt : public Stmt
   // bool has_init_expr;
   std::unique_ptr<Expr> init_expr;
 
-  Location locus;
+  location_t locus;
 
 public:
   Type *inferedType;
@@ -89,7 +89,7 @@ public:
 
   LetStmt (std::unique_ptr<Pattern> variables_pattern,
 	   std::unique_ptr<Expr> init_expr, std::unique_ptr<Type> type,
-	   std::vector<Attribute> outer_attrs, Location locus)
+	   std::vector<Attribute> outer_attrs, location_t locus)
     : outer_attrs (std::move (outer_attrs)),
       variables_pattern (std::move (variables_pattern)),
       type (std::move (type)), init_expr (std::move (init_expr)), locus (locus)
@@ -186,7 +186,7 @@ protected:
 class ExprStmt : public Stmt
 {
   std::unique_ptr<Expr> expr;
-  Location locus;
+  location_t locus;
   bool semicolon_followed;
 
 public:
@@ -206,7 +206,7 @@ public:
 
   std::vector<LetStmt *> locals;
 
-  ExprStmt (std::unique_ptr<Expr> &&expr, Location locus,
+  ExprStmt (std::unique_ptr<Expr> &&expr, location_t locus,
 	    bool semicolon_followed)
     : expr (std::move (expr)), locus (locus),
       semicolon_followed (semicolon_followed)
diff --git a/gcc/rust/ast/rust-type.h b/gcc/rust/ast/rust-type.h
index d2a5f27..4902833 100644
--- a/gcc/rust/ast/rust-type.h
+++ b/gcc/rust/ast/rust-type.h
@@ -40,7 +40,7 @@ class TraitBound : public TypeParamBound
 
   TypePath type_path;
 
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether trait bound has "for" lifetimes
@@ -48,7 +48,7 @@ public:
 
   std::vector<LifetimeParam> &get_for_lifetimes () { return for_lifetimes; }
 
-  TraitBound (TypePath type_path, Location locus, bool in_parens = false,
+  TraitBound (TypePath type_path, location_t locus, bool in_parens = false,
 	      bool opening_question_mark = false,
 	      std::vector<LifetimeParam> for_lifetimes
 	      = std::vector<LifetimeParam> ())
@@ -58,7 +58,7 @@ public:
       type_path (std::move (type_path)), locus (locus)
   {}
 
-  TraitBound (NodeId id, TypePath type_path, Location locus,
+  TraitBound (NodeId id, TypePath type_path, location_t locus,
 	      bool in_parens = false, bool opening_question_mark = false,
 	      std::vector<LifetimeParam> for_lifetimes
 	      = std::vector<LifetimeParam> ())
@@ -101,7 +101,7 @@ class ImplTraitType : public Type
   // inlined form
   std::vector<std::unique_ptr<TypeParamBound> > type_param_bounds;
 
-  Location locus;
+  location_t locus;
 
 protected:
   /* Use covariance to implement clone function as returning this object rather
@@ -114,7 +114,7 @@ protected:
 public:
   ImplTraitType (
     std::vector<std::unique_ptr<TypeParamBound> > type_param_bounds,
-    Location locus)
+    location_t locus)
     : type_param_bounds (std::move (type_param_bounds)), locus (locus)
   {}
 
@@ -165,7 +165,7 @@ class TraitObjectType : public Type
 {
   bool has_dyn;
   std::vector<std::unique_ptr<TypeParamBound> > type_param_bounds;
-  Location locus;
+  location_t locus;
 
 protected:
   /* Use covariance to implement clone function as returning this object rather
@@ -178,7 +178,7 @@ protected:
 public:
   TraitObjectType (
     std::vector<std::unique_ptr<TypeParamBound> > type_param_bounds,
-    Location locus, bool is_dyn_dispatch)
+    location_t locus, bool is_dyn_dispatch)
     : has_dyn (is_dyn_dispatch),
       type_param_bounds (std::move (type_param_bounds)), locus (locus)
   {}
@@ -232,7 +232,7 @@ public:
 class ParenthesisedType : public TypeNoBounds
 {
   std::unique_ptr<Type> type_in_parens;
-  Location locus;
+  location_t locus;
 
 protected:
   /* Use covariance to implement clone function as returning this object rather
@@ -244,7 +244,7 @@ protected:
 
 public:
   // Constructor uses Type pointer for polymorphism
-  ParenthesisedType (std::unique_ptr<Type> type_inside_parens, Location locus)
+  ParenthesisedType (std::unique_ptr<Type> type_inside_parens, location_t locus)
     : type_in_parens (std::move (type_inside_parens)), locus (locus)
   {}
 
@@ -296,7 +296,7 @@ public:
 class ImplTraitTypeOneBound : public TypeNoBounds
 {
   TraitBound trait_bound;
-  Location locus;
+  location_t locus;
 
 protected:
   /* Use covariance to implement clone function as returning this object rather
@@ -307,7 +307,7 @@ protected:
   }
 
 public:
-  ImplTraitTypeOneBound (TraitBound trait_bound, Location locus)
+  ImplTraitTypeOneBound (TraitBound trait_bound, location_t locus)
     : trait_bound (std::move (trait_bound)), locus (locus)
   {}
 
@@ -331,7 +331,7 @@ class TraitObjectTypeOneBound : public TypeNoBounds
 {
   bool has_dyn;
   TraitBound trait_bound;
-  Location locus;
+  location_t locus;
 
 protected:
   /* Use covariance to implement clone function as returning this object rather
@@ -342,7 +342,7 @@ protected:
   }
 
 public:
-  TraitObjectTypeOneBound (TraitBound trait_bound, Location locus,
+  TraitObjectTypeOneBound (TraitBound trait_bound, location_t locus,
 			   bool is_dyn_dispatch = false)
     : has_dyn (is_dyn_dispatch), trait_bound (std::move (trait_bound)),
       locus (locus)
@@ -379,13 +379,13 @@ class TypePath; // definition moved to "rust-path.h"
 class TupleType : public TypeNoBounds
 {
   std::vector<std::unique_ptr<Type> > elems;
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether the tuple type is the unit type, i.e. has no elements.
   bool is_unit_type () const { return elems.empty (); }
 
-  TupleType (std::vector<std::unique_ptr<Type> > elems, Location locus)
+  TupleType (std::vector<std::unique_ptr<Type> > elems, location_t locus)
     : elems (std::move (elems)), locus (locus)
   {}
 
@@ -440,7 +440,7 @@ protected:
  * Represented as "!". */
 class NeverType : public TypeNoBounds
 {
-  Location locus;
+  location_t locus;
 
 protected:
   /* Use covariance to implement clone function as returning this object rather
@@ -451,7 +451,7 @@ protected:
   }
 
 public:
-  NeverType (Location locus) : locus (locus) {}
+  NeverType (location_t locus) : locus (locus) {}
 
   std::string as_string () const override { return "! (never type)"; }
 
@@ -473,7 +473,7 @@ public:
 private:
   PointerType pointer_type;
   std::unique_ptr<TypeNoBounds> type;
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether the pointer is mutable or constant.
@@ -481,7 +481,8 @@ public:
 
   // Constructor requires pointer for polymorphism reasons
   RawPointerType (PointerType pointer_type,
-		  std::unique_ptr<TypeNoBounds> type_no_bounds, Location locus)
+		  std::unique_ptr<TypeNoBounds> type_no_bounds,
+		  location_t locus)
     : pointer_type (pointer_type), type (std::move (type_no_bounds)),
       locus (locus)
   {}
@@ -535,7 +536,7 @@ class ReferenceType : public TypeNoBounds
 
   bool has_mut;
   std::unique_ptr<TypeNoBounds> type;
-  Location locus;
+  location_t locus;
 
 public:
   // Returns whether the reference is mutable or immutable.
@@ -546,7 +547,7 @@ public:
 
   // Constructor
   ReferenceType (bool is_mut, std::unique_ptr<TypeNoBounds> type_no_bounds,
-		 Location locus, Lifetime lifetime = Lifetime::error ())
+		 location_t locus, Lifetime lifetime = Lifetime::error ())
     : lifetime (std::move (lifetime)), has_mut (is_mut),
       type (std::move (type_no_bounds)), locus (locus)
   {}
@@ -605,12 +606,12 @@ class ArrayType : public TypeNoBounds
 {
   std::unique_ptr<Type> elem_type;
   std::unique_ptr<Expr> size;
-  Location locus;
+  location_t locus;
 
 public:
   // Constructor requires pointers for polymorphism
   ArrayType (std::unique_ptr<Type> type, std::unique_ptr<Expr> array_size,
-	     Location locus)
+	     location_t locus)
     : elem_type (std::move (type)), size (std::move (array_size)), locus (locus)
   {}
 
@@ -667,11 +668,11 @@ protected:
 class SliceType : public TypeNoBounds
 {
   std::unique_ptr<Type> elem_type;
-  Location locus;
+  location_t locus;
 
 public:
   // Constructor requires pointer for polymorphism
-  SliceType (std::unique_ptr<Type> type, Location locus)
+  SliceType (std::unique_ptr<Type> type, location_t locus)
     : elem_type (std::move (type)), locus (locus)
   {}
 
@@ -719,7 +720,7 @@ protected:
  * pattern) */
 class InferredType : public TypeNoBounds
 {
-  Location locus;
+  location_t locus;
 
   // e.g. Vec<_> = whatever
 protected:
@@ -731,7 +732,7 @@ protected:
   }
 
 public:
-  InferredType (Location locus) : locus (locus) {}
+  InferredType (location_t locus) : locus (locus) {}
 
   std::string as_string () const override;
 
@@ -761,12 +762,12 @@ private:
   ParamKind param_kind;
   Identifier name; // technically, can be an identifier or '_'
 
-  Location locus;
+  location_t locus;
 
 public:
   MaybeNamedParam (Identifier name, ParamKind param_kind,
 		   std::unique_ptr<Type> param_type,
-		   std::vector<Attribute> outer_attrs, Location locus)
+		   std::vector<Attribute> outer_attrs, location_t locus)
     : outer_attrs (std::move (outer_attrs)),
       param_type (std::move (param_type)), param_kind (param_kind),
       name (std::move (name)), locus (locus)
@@ -851,7 +852,7 @@ class BareFunctionType : public TypeNoBounds
   // BareFunctionReturnType return_type;
   std::unique_ptr<TypeNoBounds> return_type; // inlined version
 
-  Location locus;
+  location_t locus;
 
 public:
   // Whether a return type is defined with the function.
@@ -874,7 +875,7 @@ public:
 		    FunctionQualifiers qualifiers,
 		    std::vector<MaybeNamedParam> named_params, bool is_variadic,
 		    std::vector<Attribute> variadic_attrs,
-		    std::unique_ptr<TypeNoBounds> type, Location locus)
+		    std::unique_ptr<TypeNoBounds> type, location_t locus)
     : for_lifetimes (std::move (lifetime_params)),
       function_qualifiers (std::move (qualifiers)),
       params (std::move (named_params)), _is_variadic (is_variadic),