diff options
Diffstat (limited to 'gcc/rust/ast/rust-pattern.h')
| -rw-r--r-- | gcc/rust/ast/rust-pattern.h | 191 |
1 files changed, 126 insertions, 65 deletions
diff --git a/gcc/rust/ast/rust-pattern.h b/gcc/rust/ast/rust-pattern.h index 5ae68ab..3a87a83 100644 --- a/gcc/rust/ast/rust-pattern.h +++ b/gcc/rust/ast/rust-pattern.h @@ -94,7 +94,7 @@ public: // fix to prevent null pointer dereference if (other.to_bind != nullptr) to_bind = other.to_bind->clone_pattern (); - else + else to_bind = nullptr; return *this; @@ -110,12 +110,13 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: is this better? Or is a "vis_pattern" better? - std::unique_ptr<Pattern> &get_pattern_to_bind () { + std::unique_ptr<Pattern> &get_pattern_to_bind () + { rust_assert (has_pattern_to_bind ()); return to_bind; } - Identifier get_ident() const { return variable_ident; } + Identifier get_ident () const { return variable_ident; } protected: /* Use covariance to implement clone function as returning this object rather @@ -319,12 +320,14 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: is this better? or is a "vis_bound" better? - std::unique_ptr<RangePatternBound>& get_lower_bound () { + std::unique_ptr<RangePatternBound> &get_lower_bound () + { rust_assert (lower != nullptr); return lower; } - std::unique_ptr<RangePatternBound>& get_upper_bound () { + std::unique_ptr<RangePatternBound> &get_upper_bound () + { rust_assert (upper != nullptr); return upper; } @@ -382,7 +385,8 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: is this better? Or is a "vis_pattern" better? - std::unique_ptr<Pattern> &get_referenced_pattern () { + std::unique_ptr<Pattern> &get_referenced_pattern () + { rust_assert (pattern != nullptr); return pattern; } @@ -508,10 +512,14 @@ public: // based on idea of tuple pattern no longer existing void mark_for_strip () override { tuple_pattern = nullptr; } - bool is_marked_for_strip () const override { return tuple_pattern == nullptr; } + bool is_marked_for_strip () const override + { + return tuple_pattern == nullptr; + } // TODO: is this better? Or is a "vis_pattern" better? - std::unique_ptr<Pattern> &get_index_pattern () { + std::unique_ptr<Pattern> &get_index_pattern () + { rust_assert (tuple_pattern != nullptr); return tuple_pattern; } @@ -577,10 +585,14 @@ public: // based on idea of identifier pattern no longer existing void mark_for_strip () override { ident_pattern = nullptr; } - bool is_marked_for_strip () const override { return ident_pattern == nullptr; } + bool is_marked_for_strip () const override + { + return ident_pattern == nullptr; + } // TODO: is this better? Or is a "vis_pattern" better? - std::unique_ptr<Pattern> &get_ident_pattern () { + std::unique_ptr<Pattern> &get_ident_pattern () + { rust_assert (ident_pattern != nullptr); return ident_pattern; } @@ -630,11 +642,11 @@ struct StructPatternElements { private: // bool has_struct_pattern_fields; - std::vector<std::unique_ptr<StructPatternField>> fields; + std::vector<std::unique_ptr<StructPatternField> > fields; bool has_struct_pattern_etc; std::vector<Attribute> struct_pattern_etc_attrs; - //StructPatternEtc etc; + // StructPatternEtc etc; // must have at least one of the two and maybe both @@ -655,7 +667,7 @@ public: // Constructor for StructPatternElements with both (potentially) StructPatternElements ( - std::vector<std::unique_ptr<StructPatternField>> fields, + std::vector<std::unique_ptr<StructPatternField> > fields, std::vector<Attribute> etc_attrs) : fields (std::move (fields)), has_struct_pattern_etc (true), struct_pattern_etc_attrs (std::move (etc_attrs)) @@ -663,14 +675,15 @@ public: // Constructor for StructPatternElements with no StructPatternEtc StructPatternElements ( - std::vector<std::unique_ptr<StructPatternField>> fields) + std::vector<std::unique_ptr<StructPatternField> > fields) : fields (std::move (fields)), has_struct_pattern_etc (false), struct_pattern_etc_attrs () {} // Copy constructor with vector clone StructPatternElements (StructPatternElements const &other) - : has_struct_pattern_etc (other.has_struct_pattern_etc), struct_pattern_etc_attrs (other.struct_pattern_etc_attrs) + : has_struct_pattern_etc (other.has_struct_pattern_etc), + struct_pattern_etc_attrs (other.struct_pattern_etc_attrs) { fields.reserve (other.fields.size ()); for (const auto &e : other.fields) @@ -698,21 +711,35 @@ public: static StructPatternElements create_empty () { return StructPatternElements ( - std::vector<std::unique_ptr<StructPatternField>> ()); + std::vector<std::unique_ptr<StructPatternField> > ()); } std::string as_string () const; // TODO: seems kinda dodgy. Think of better way. - std::vector<std::unique_ptr<StructPatternField>> &get_struct_pattern_fields () { return fields; } - const std::vector<std::unique_ptr<StructPatternField>> &get_struct_pattern_fields () const { return fields; } + std::vector<std::unique_ptr<StructPatternField> > & + get_struct_pattern_fields () + { + return fields; + } + const std::vector<std::unique_ptr<StructPatternField> > & + get_struct_pattern_fields () const + { + return fields; + } - std::vector<Attribute> &get_etc_outer_attrs () { return struct_pattern_etc_attrs; } - const std::vector<Attribute> &get_etc_outer_attrs () const { return struct_pattern_etc_attrs; } + std::vector<Attribute> &get_etc_outer_attrs () + { + return struct_pattern_etc_attrs; + } + const std::vector<Attribute> &get_etc_outer_attrs () const + { + return struct_pattern_etc_attrs; + } - void strip_etc () - { - has_struct_pattern_etc = false; + void strip_etc () + { + has_struct_pattern_etc = false; struct_pattern_etc_attrs.clear (); struct_pattern_etc_attrs.shrink_to_fit (); } @@ -752,7 +779,10 @@ public: // TODO: seems kinda dodgy. Think of better way. StructPatternElements &get_struct_pattern_elems () { return elems; } - const StructPatternElements &get_struct_pattern_elems () const { return elems; } + const StructPatternElements &get_struct_pattern_elems () const + { + return elems; + } PathInExpression &get_path () { return path; } const PathInExpression &get_path () const { return path; } @@ -792,10 +822,10 @@ protected: // Class for non-ranged tuple struct pattern patterns class TupleStructItemsNoRange : public TupleStructItems { - std::vector<std::unique_ptr<Pattern>> patterns; + std::vector<std::unique_ptr<Pattern> > patterns; public: - TupleStructItemsNoRange (std::vector<std::unique_ptr<Pattern>> patterns) + TupleStructItemsNoRange (std::vector<std::unique_ptr<Pattern> > patterns) : patterns (std::move (patterns)) {} @@ -827,8 +857,11 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: seems kinda dodgy. Think of better way. - std::vector<std::unique_ptr<Pattern>> &get_patterns () { return patterns; } - const std::vector<std::unique_ptr<Pattern>> &get_patterns () const { return patterns; } + std::vector<std::unique_ptr<Pattern> > &get_patterns () { return patterns; } + const std::vector<std::unique_ptr<Pattern> > &get_patterns () const + { + return patterns; + } protected: /* Use covariance to implement clone function as returning this object rather @@ -842,12 +875,12 @@ protected: // Class for ranged tuple struct pattern patterns class TupleStructItemsRange : public TupleStructItems { - std::vector<std::unique_ptr<Pattern>> lower_patterns; - std::vector<std::unique_ptr<Pattern>> upper_patterns; + std::vector<std::unique_ptr<Pattern> > lower_patterns; + std::vector<std::unique_ptr<Pattern> > upper_patterns; public: - TupleStructItemsRange (std::vector<std::unique_ptr<Pattern>> lower_patterns, - std::vector<std::unique_ptr<Pattern>> upper_patterns) + TupleStructItemsRange (std::vector<std::unique_ptr<Pattern> > lower_patterns, + std::vector<std::unique_ptr<Pattern> > upper_patterns) : lower_patterns (std::move (lower_patterns)), upper_patterns (std::move (upper_patterns)) {} @@ -887,12 +920,24 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: seems kinda dodgy. Think of better way. - std::vector<std::unique_ptr<Pattern>> &get_lower_patterns () { return lower_patterns; } - const std::vector<std::unique_ptr<Pattern>> &get_lower_patterns () const { return lower_patterns; } + std::vector<std::unique_ptr<Pattern> > &get_lower_patterns () + { + return lower_patterns; + } + const std::vector<std::unique_ptr<Pattern> > &get_lower_patterns () const + { + return lower_patterns; + } // TODO: seems kinda dodgy. Think of better way. - std::vector<std::unique_ptr<Pattern>> &get_upper_patterns () { return upper_patterns; } - const std::vector<std::unique_ptr<Pattern>> &get_upper_patterns () const { return upper_patterns; } + std::vector<std::unique_ptr<Pattern> > &get_upper_patterns () + { + return upper_patterns; + } + const std::vector<std::unique_ptr<Pattern> > &get_upper_patterns () const + { + return upper_patterns; + } protected: /* Use covariance to implement clone function as returning this object rather @@ -924,8 +969,7 @@ public: {} // Copy constructor required to clone - TupleStructPattern (TupleStructPattern const &other) - : path (other.path) + TupleStructPattern (TupleStructPattern const &other) : path (other.path) { // guard to protect from null dereference if (other.items != nullptr) @@ -956,10 +1000,10 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: seems kinda dodgy. Think of better way. - std::unique_ptr<TupleStructItems> &get_items () - { + std::unique_ptr<TupleStructItems> &get_items () + { rust_assert (has_items ()); - return items; + return items; } PathInExpression &get_path () { return path; } @@ -1036,10 +1080,10 @@ TuplePatternItemsSingle(*this); // Class representing TuplePattern patterns where there are multiple patterns class TuplePatternItemsMultiple : public TuplePatternItems { - std::vector<std::unique_ptr<Pattern>> patterns; + std::vector<std::unique_ptr<Pattern> > patterns; public: - TuplePatternItemsMultiple (std::vector<std::unique_ptr<Pattern>> patterns) + TuplePatternItemsMultiple (std::vector<std::unique_ptr<Pattern> > patterns) : patterns (std::move (patterns)) {} @@ -1071,8 +1115,11 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: seems kinda dodgy. Think of better way. - std::vector<std::unique_ptr<Pattern>> &get_patterns () { return patterns; } - const std::vector<std::unique_ptr<Pattern>> &get_patterns () const { return patterns; } + std::vector<std::unique_ptr<Pattern> > &get_patterns () { return patterns; } + const std::vector<std::unique_ptr<Pattern> > &get_patterns () const + { + return patterns; + } protected: /* Use covariance to implement clone function as returning this object rather @@ -1086,13 +1133,13 @@ protected: // Class representing TuplePattern patterns where there are a range of patterns class TuplePatternItemsRanged : public TuplePatternItems { - std::vector<std::unique_ptr<Pattern>> lower_patterns; - std::vector<std::unique_ptr<Pattern>> upper_patterns; + std::vector<std::unique_ptr<Pattern> > lower_patterns; + std::vector<std::unique_ptr<Pattern> > upper_patterns; public: TuplePatternItemsRanged ( - std::vector<std::unique_ptr<Pattern>> lower_patterns, - std::vector<std::unique_ptr<Pattern>> upper_patterns) + std::vector<std::unique_ptr<Pattern> > lower_patterns, + std::vector<std::unique_ptr<Pattern> > upper_patterns) : lower_patterns (std::move (lower_patterns)), upper_patterns (std::move (upper_patterns)) {} @@ -1133,12 +1180,24 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: seems kinda dodgy. Think of better way. - std::vector<std::unique_ptr<Pattern>> &get_lower_patterns () { return lower_patterns; } - const std::vector<std::unique_ptr<Pattern>> &get_lower_patterns () const { return lower_patterns; } + std::vector<std::unique_ptr<Pattern> > &get_lower_patterns () + { + return lower_patterns; + } + const std::vector<std::unique_ptr<Pattern> > &get_lower_patterns () const + { + return lower_patterns; + } // TODO: seems kinda dodgy. Think of better way. - std::vector<std::unique_ptr<Pattern>> &get_upper_patterns () { return upper_patterns; } - const std::vector<std::unique_ptr<Pattern>> &get_upper_patterns () const { return upper_patterns; } + std::vector<std::unique_ptr<Pattern> > &get_upper_patterns () + { + return upper_patterns; + } + const std::vector<std::unique_ptr<Pattern> > &get_upper_patterns () const + { + return upper_patterns; + } protected: /* Use covariance to implement clone function as returning this object rather @@ -1167,8 +1226,7 @@ public: {} // Copy constructor requires clone - TuplePattern (TuplePattern const &other) - : locus (other.locus) + TuplePattern (TuplePattern const &other) : locus (other.locus) { // guard to prevent null dereference if (other.items != nullptr) @@ -1195,10 +1253,10 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: seems kinda dodgy. Think of better way. - std::unique_ptr<TuplePatternItems> &get_items () - { + std::unique_ptr<TuplePatternItems> &get_items () + { rust_assert (has_tuple_pattern_items ()); - return items; + return items; } protected: @@ -1251,10 +1309,10 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: seems kinda dodgy. Think of better way. - std::unique_ptr<Pattern> &get_pattern_in_parens () - { + std::unique_ptr<Pattern> &get_pattern_in_parens () + { rust_assert (pattern_in_parens != nullptr); - return pattern_in_parens; + return pattern_in_parens; } protected: @@ -1269,13 +1327,13 @@ protected: // AST node representing patterns that can match slices and arrays class SlicePattern : public Pattern { - std::vector<std::unique_ptr<Pattern>> items; + std::vector<std::unique_ptr<Pattern> > items; Location locus; 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 locus) : items (std::move (items)), locus (locus) {} @@ -1309,8 +1367,11 @@ public: void accept_vis (ASTVisitor &vis) override; // TODO: seems kinda dodgy. Think of better way. - std::vector<std::unique_ptr<Pattern>> &get_items () { return items; } - const std::vector<std::unique_ptr<Pattern>> &get_items () const { return items; } + std::vector<std::unique_ptr<Pattern> > &get_items () { return items; } + const std::vector<std::unique_ptr<Pattern> > &get_items () const + { + return items; + } protected: /* Use covariance to implement clone function as returning this object rather |