diff options
Diffstat (limited to 'gcc/rust/ast')
| -rw-r--r-- | gcc/rust/ast/rust-ast-collector.cc | 2 | ||||
| -rw-r--r-- | gcc/rust/ast/rust-ast.cc | 4 | ||||
| -rw-r--r-- | gcc/rust/ast/rust-ast.h | 40 | ||||
| -rw-r--r-- | gcc/rust/ast/rust-expr.h | 193 | ||||
| -rw-r--r-- | gcc/rust/ast/rust-item.h | 156 | ||||
| -rw-r--r-- | gcc/rust/ast/rust-macro.h | 46 | ||||
| -rw-r--r-- | gcc/rust/ast/rust-path.cc | 2 | ||||
| -rw-r--r-- | gcc/rust/ast/rust-path.h | 71 | ||||
| -rw-r--r-- | gcc/rust/ast/rust-pattern.h | 62 | ||||
| -rw-r--r-- | gcc/rust/ast/rust-stmt.h | 12 | ||||
| -rw-r--r-- | gcc/rust/ast/rust-type.h | 63 |
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), |