Patterns include TuplePattern, TupleStructPattern & SlicePattern. Besides making their pattern
items container class inherit from a common `PatternItems` base class just like in HIR for
better standardization, mentions of `Range` are also changed to `HasRest` or `NoRest`.
gcc/rust/ChangeLog:
* ast/rust-pattern.h:
- Add a new base abstract class `PatternItems` which are used by pattern items class
class derivatives for `TuplePattern`, `TupleStructPattern` & `SlicePattern`.
- Standardized the derived class names to have `HasRest` or `NoRest` as suffixes.
- Values for the common `ItemType` enum is updated to `HAS_REST` or `NO_REST`.
* ast/rust-pattern.cc: Renamed the classes accordingly.
* ast/rust-ast-collector.cc: Renamed the classes accordingly.
* ast/rust-ast-collector.h: Renamed the classes accordingly.
* ast/rust-ast-full-decls.h: Renamed the classes accordingly.
* ast/rust-ast-visitor.cc: Renamed the classes accordingly.
* ast/rust-ast-visitor.h: Renamed the classes accordingly.
* ast/rust-desugar-for-loops.cc: Renamed the classes accordingly.
* ast/rust-desugar-question-mark.cc: Renamed the classes accordingly.
* expand/rust-cfg-strip.cc: Renamed the classes accordingly.
* expand/rust-cfg-strip.h: Renamed the classes accordingly.
* expand/rust-derive-clone.cc: Renamed the classes accordingly.
* expand/rust-derive-cmp-common.cc: Renamed the classes accordingly.
* expand/rust-derive-hash.cc: Renamed the classes accordingly.
* expand/rust-derive-ord.cc: Renamed the classes accordingly.
* expand/rust-derive-partial-eq.cc: Renamed the classes accordingly.
* expand/rust-derive.h: Renamed the classes accordingly.
* expand/rust-expand-visitor.cc: Renamed the classes accordingly.
* expand/rust-expand-visitor.h: Renamed the classes accordingly.
* hir/rust-ast-lower-base.cc: Renamed the classes accordingly.
* hir/rust-ast-lower-base.h: Renamed the classes accordingly.
* hir/rust-ast-lower-pattern.cc: Renamed the classes accordingly.
* hir/tree/rust-hir-pattern.h: Renamed the classes accordingly.
* parse/rust-parse-impl.h: Renamed the classes accordingly.
* resolve/rust-ast-resolve-base.cc: Renamed the classes accordingly.
* resolve/rust-ast-resolve-base.h: Renamed the classes accordingly.
* resolve/rust-ast-resolve-pattern.cc: Renamed the classes accordingly.
* util/rust-attributes.cc: Renamed the classes accordingly.
* util/rust-attributes.h: Renamed the classes accordingly.
Signed-off-by: Yap Zhi Heng <yapzhhg@gmail.com>
// void TokenCollector::visit(TupleStructItems& ){}
void
-TokenCollector::visit (TupleStructItemsNoRange &pattern)
+TokenCollector::visit (TupleStructItemsNoRest &pattern)
{
visit_items_joined_by_separator (pattern.get_patterns ());
}
void
-TokenCollector::visit (TupleStructItemsRange &pattern)
+TokenCollector::visit (TupleStructItemsHasRest &pattern)
{
for (auto &lower : pattern.get_lower_patterns ())
{
// {}
void
-TokenCollector::visit (TuplePatternItemsMultiple &pattern)
+TokenCollector::visit (TuplePatternItemsNoRest &pattern)
{
visit_items_joined_by_separator (pattern.get_patterns (), COMMA);
}
void
-TokenCollector::visit (TuplePatternItemsRanged &pattern)
+TokenCollector::visit (TuplePatternItemsHasRest &pattern)
{
for (auto &lower : pattern.get_lower_patterns ())
{
void visit (StructPatternFieldIdent &field);
void visit (StructPattern &pattern);
// void visit(TupleStructItems& tuple_items);
- void visit (TupleStructItemsNoRange &tuple_items);
- void visit (TupleStructItemsRange &tuple_items);
+ void visit (TupleStructItemsNoRest &tuple_items);
+ void visit (TupleStructItemsHasRest &tuple_items);
void visit (TupleStructPattern &pattern);
// void visit(TuplePatternItems& tuple_items);
- void visit (TuplePatternItemsMultiple &tuple_items);
- void visit (TuplePatternItemsRanged &tuple_items);
+ void visit (TuplePatternItemsNoRest &tuple_items);
+ void visit (TuplePatternItemsHasRest &tuple_items);
void visit (TuplePattern &pattern);
void visit (GroupedPattern &pattern);
void visit (SlicePatternItemsNoRest &items);
class StructPatternElements;
class StructPattern;
class TupleStructItems;
-class TupleStructItemsNoRange;
-class TupleStructItemsRange;
+class TupleStructItemsNoRest;
+class TupleStructItemsHasRest;
class TupleStructPattern;
class TuplePatternItems;
-class TuplePatternItemsMultiple;
-class TuplePatternItemsRanged;
+class TuplePatternItemsNoRest;
+class TuplePatternItemsHasRest;
class TuplePattern;
class GroupedPattern;
class SlicePatternItemsNoRest;
}
void
-DefaultASTVisitor::visit (AST::TupleStructItemsNoRange &tuple_items)
+DefaultASTVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
{
for (auto &pattern : tuple_items.get_patterns ())
visit (pattern);
}
void
-DefaultASTVisitor::visit (AST::TupleStructItemsRange &tuple_items)
+DefaultASTVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
{
for (auto &lower : tuple_items.get_lower_patterns ())
visit (lower);
}
void
-DefaultASTVisitor::visit (AST::TuplePatternItemsMultiple &tuple_items)
+DefaultASTVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
{
for (auto &pattern : tuple_items.get_patterns ())
visit (pattern);
}
void
-DefaultASTVisitor::visit (AST::TuplePatternItemsRanged &tuple_items)
+DefaultASTVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
{
for (auto &lower : tuple_items.get_lower_patterns ())
visit (lower);
virtual void visit (StructPatternFieldIdent &field) = 0;
virtual void visit (StructPattern &pattern) = 0;
// virtual void visit(TupleStructItems& tuple_items) = 0;
- virtual void visit (TupleStructItemsNoRange &tuple_items) = 0;
- virtual void visit (TupleStructItemsRange &tuple_items) = 0;
+ virtual void visit (TupleStructItemsNoRest &tuple_items) = 0;
+ virtual void visit (TupleStructItemsHasRest &tuple_items) = 0;
virtual void visit (TupleStructPattern &pattern) = 0;
// virtual void visit(TuplePatternItems& tuple_items) = 0;
- virtual void visit (TuplePatternItemsMultiple &tuple_items) = 0;
- virtual void visit (TuplePatternItemsRanged &tuple_items) = 0;
+ virtual void visit (TuplePatternItemsNoRest &tuple_items) = 0;
+ virtual void visit (TuplePatternItemsHasRest &tuple_items) = 0;
virtual void visit (TuplePattern &pattern) = 0;
virtual void visit (GroupedPattern &pattern) = 0;
virtual void visit (SlicePatternItemsNoRest &items) = 0;
virtual void visit (AST::StructPatternFieldIdentPat &field) override;
virtual void visit (AST::StructPatternFieldIdent &field) override;
virtual void visit (AST::StructPattern &pattern) override;
- virtual void visit (AST::TupleStructItemsNoRange &tuple_items) override;
- virtual void visit (AST::TupleStructItemsRange &tuple_items) override;
+ virtual void visit (AST::TupleStructItemsNoRest &tuple_items) override;
+ virtual void visit (AST::TupleStructItemsHasRest &tuple_items) override;
virtual void visit (AST::TupleStructPattern &pattern) override;
- virtual void visit (AST::TuplePatternItemsMultiple &tuple_items) override;
- virtual void visit (AST::TuplePatternItemsRanged &tuple_items) override;
+ virtual void visit (AST::TuplePatternItemsNoRest &tuple_items) override;
+ virtual void visit (AST::TuplePatternItemsHasRest &tuple_items) override;
virtual void visit (AST::TuplePattern &pattern) override;
virtual void visit (AST::GroupedPattern &pattern) override;
virtual void visit (AST::SlicePatternItemsNoRest &items) override;
patterns.emplace_back (std::move (val));
auto pattern_item = std::unique_ptr<TupleStructItems> (
- new TupleStructItemsNoRange (std::move (patterns)));
+ new TupleStructItemsNoRest (std::move (patterns)));
auto pattern = std::unique_ptr<Pattern> (new TupleStructPattern (
builder.path_in_expression (LangItem::Kind::OPTION_SOME),
std::move (pattern_item)));
patterns.emplace_back (std::move (val));
auto pattern_item = std::unique_ptr<TupleStructItems> (
- new TupleStructItemsNoRange (std::move (patterns)));
+ new TupleStructItemsNoRest (std::move (patterns)));
auto pattern = std::unique_ptr<Pattern> (new TupleStructPattern (
builder.path_in_expression (LangItem::Kind::RESULT_OK),
std::move (pattern_item)));
patterns.emplace_back (std::move (val));
auto pattern_item = std::unique_ptr<TupleStructItems> (
- new TupleStructItemsNoRange (std::move (patterns)));
+ new TupleStructItemsNoRest (std::move (patterns)));
auto pattern = std::unique_ptr<Pattern> (new TupleStructPattern (
builder.path_in_expression (LangItem::Kind::RESULT_ERR),
std::move (pattern_item)));
}
std::string
-TupleStructItemsNoRange::as_string () const
+TupleStructItemsNoRest::as_string () const
{
std::string str;
}
std::string
-TupleStructItemsRange::as_string () const
+TupleStructItemsHasRest::as_string () const
{
std::string str ("\n Lower patterns: ");
}
std::string
-TuplePatternItemsMultiple::as_string () const
+TuplePatternItemsNoRest::as_string () const
{
std::string str;
}
std::string
-TuplePatternItemsRanged::as_string () const
+TuplePatternItemsHasRest::as_string () const
{
std::string str;
}
void
-TuplePatternItemsRanged::accept_vis (ASTVisitor &vis)
+TuplePatternItemsHasRest::accept_vis (ASTVisitor &vis)
{
vis.visit (*this);
}
}
void
-TuplePatternItemsMultiple::accept_vis (ASTVisitor &vis)
+TuplePatternItemsNoRest::accept_vis (ASTVisitor &vis)
{
vis.visit (*this);
}
}
void
-TupleStructItemsNoRange::accept_vis (ASTVisitor &vis)
+TupleStructItemsNoRest::accept_vis (ASTVisitor &vis)
{
vis.visit (*this);
}
void
-TupleStructItemsRange::accept_vis (ASTVisitor &vis)
+TupleStructItemsHasRest::accept_vis (ASTVisitor &vis)
{
vis.visit (*this);
}
}
};
-// Base abstract class for patterns used in TupleStructPattern
-class TupleStructItems
+// Base abstract class for TupleStructItems, TuplePatternItems &
+// SlicePatternItems
+class PatternItems
{
public:
enum ItemType
{
- RANGE,
- NO_RANGE
+ NO_REST,
+ HAS_REST,
};
- virtual ~TupleStructItems () {}
+ virtual ~PatternItems () {}
// TODO: should this store location data?
// Unique pointer custom clone function
- std::unique_ptr<TupleStructItems> clone_tuple_struct_items () const
+ std::unique_ptr<PatternItems> clone_pattern_items () const
{
- return std::unique_ptr<TupleStructItems> (clone_tuple_struct_items_impl ());
+ return std::unique_ptr<PatternItems> (clone_pattern_items_impl ());
}
virtual std::string as_string () const = 0;
-
+ virtual ItemType get_item_type () const = 0;
virtual void accept_vis (ASTVisitor &vis) = 0;
- virtual ItemType get_item_type () const = 0;
+protected:
+ virtual PatternItems *clone_pattern_items_impl () const = 0;
+};
+
+// Base abstract class for patterns used in TupleStructPattern
+class TupleStructItems : public PatternItems
+{
+public:
+ // Unique pointer custom clone function
+ std::unique_ptr<TupleStructItems> clone_tuple_struct_items () const
+ {
+ return std::unique_ptr<TupleStructItems> (clone_pattern_items_impl ());
+ }
protected:
// pure virtual clone implementation
- virtual TupleStructItems *clone_tuple_struct_items_impl () const = 0;
+ virtual TupleStructItems *clone_pattern_items_impl () const = 0;
};
// Class for non-ranged tuple struct pattern patterns
-class TupleStructItemsNoRange : public TupleStructItems
+class TupleStructItemsNoRest : public TupleStructItems
{
std::vector<std::unique_ptr<Pattern>> patterns;
public:
- TupleStructItemsNoR
ange (std::vector<std::unique_ptr<Pattern>> patterns)
+ TupleStructItemsNoR
est (std::vector<std::unique_ptr<Pattern>> patterns)
: patterns (std::move (patterns))
{}
// Copy constructor with vector clone
- TupleStructItemsNoRange (TupleStructItemsNoRange const &other)
+ TupleStructItemsNoRest (TupleStructItemsNoRest const &other)
{
patterns.reserve (other.patterns.size ());
for (const auto &e : other.patterns)
}
// Overloaded assignment operator with vector clone
- TupleStructItemsNoRange &operator= (TupleStructItemsNoRange const &other)
+ TupleStructItemsNoRest &operator= (TupleStructItemsNoRest const &other)
{
patterns.clear ();
patterns.reserve (other.patterns.size ());
}
// move constructors
- TupleStructItemsNoRange (TupleStructItemsNoRange &&other) = default;
- TupleStructItemsNoRange &operator= (TupleStructItemsNoRange &&other)
- = default;
+ TupleStructItemsNoRest (TupleStructItemsNoRest &&other) = default;
+ TupleStructItemsNoRest &operator= (TupleStructItemsNoRest &&other) = default;
std::string as_string () const override;
return patterns;
}
- ItemType get_item_type () const override final { return ItemType::NO_RANGE; }
+ ItemType get_item_type () const override final { return ItemType::NO_REST; }
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
- TupleStructItemsNoRange *clone_tuple_struct_items_impl () const override
+ TupleStructItemsNoRest *clone_pattern_items_impl () const override
{
- return new TupleStructItemsNoRange (*this);
+ return new TupleStructItemsNoRest (*this);
}
};
// Class for ranged tuple struct pattern patterns
-class TupleStructItemsRange : public TupleStructItems
+class TupleStructItemsHasRest : public TupleStructItems
{
std::vector<std::unique_ptr<Pattern>> lower_patterns;
std::vector<std::unique_ptr<Pattern>> upper_patterns;
public:
- TupleStructItems
Range (std::vector<std::unique_ptr<Pattern>> lower_patterns,
- std::vector<std::unique_ptr<Pattern>> upper_patterns)
+ TupleStructItems
HasRest (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))
{}
// Copy constructor with vector clone
- TupleStructItemsRange (TupleStructItemsRange const &other)
+ TupleStructItemsHasRest (TupleStructItemsHasRest const &other)
{
lower_patterns.reserve (other.lower_patterns.size ());
for (const auto &e : other.lower_patterns)
}
// Overloaded assignment operator to clone
- TupleStructItemsRange &operator= (TupleStructItemsRange const &other)
+ TupleStructItemsHasRest &operator= (TupleStructItemsHasRest const &other)
{
lower_patterns.clear ();
lower_patterns.reserve (other.lower_patterns.size ());
}
// move constructors
- TupleStructItemsRange (TupleStructItemsRange &&other) = default;
- TupleStructItemsRange &operator= (TupleStructItemsRange &&other) = default;
+ TupleStructItemsHasRest (TupleStructItemsHasRest &&other) = default;
+ TupleStructItemsHasRest &operator= (TupleStructItemsHasRest &&other)
+ = default;
std::string as_string () const override;
return upper_patterns;
}
- ItemType get_item_type () const override final { return ItemType::RANGE; }
+ ItemType get_item_type () const override final { return ItemType::HAS_REST; }
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
- TupleStructItemsRange *clone_tuple_struct_items_impl () const override
+ TupleStructItemsHasRest *clone_pattern_items_impl () const override
{
- return new TupleStructItemsRange (*this);
+ return new TupleStructItemsHasRest (*this);
}
};
};
// Base abstract class representing TuplePattern patterns
-class TuplePatternItems
+class TuplePatternItems : public PatternItems
{
public:
- enum TuplePatternItemType
- {
- MULTIPLE,
- RANGED,
- };
-
- virtual ~TuplePatternItems () {}
-
- // TODO: should this store location data?
-
// Unique pointer custom clone function
std::unique_ptr<TuplePatternItems> clone_tuple_pattern_items () const
{
- return std::unique_ptr<TuplePatternItems> (
- clone_tuple_pattern_items_impl ());
+ return std::unique_ptr<TuplePatternItems> (clone_pattern_items_impl ());
}
- virtual std::string as_string () const = 0;
-
- virtual void accept_vis (ASTVisitor &vis) = 0;
-
- virtual TuplePatternItemType get_pattern_type () const = 0;
-
protected:
// pure virtual clone implementation
- virtual TuplePatternItems *clone_tuple_pattern_items_impl () const = 0;
+ virtual TuplePatternItems *clone_pattern_items_impl () const = 0;
};
-// Class representing TuplePattern patterns where there are multiple patterns
-class TuplePatternItemsMultiple : public TuplePatternItems
+// Class representing TuplePattern patterns which contains no rest pattern
+class TuplePatternItemsNoRest : public TuplePatternItems
{
std::vector<std::unique_ptr<Pattern>> patterns;
public:
- TuplePatternItems
Multiple (std::vector<std::unique_ptr<Pattern>> patterns)
+ TuplePatternItems
NoRest (std::vector<std::unique_ptr<Pattern>> patterns)
: patterns (std::move (patterns))
{}
// Copy constructor with vector clone
- TuplePatternItemsMultiple (TuplePatternItemsMultiple const &other)
+ TuplePatternItemsNoRest (TuplePatternItemsNoRest const &other)
{
patterns.reserve (other.patterns.size ());
for (const auto &e : other.patterns)
}
// Overloaded assignment operator to vector clone
- TuplePatternItemsMultiple &operator= (TuplePatternItemsMultiple const &other)
+ TuplePatternItemsNoRest &operator= (TuplePatternItemsNoRest const &other)
{
patterns.clear ();
patterns.reserve (other.patterns.size ());
}
// move constructors
- TuplePatternItemsMultiple (TuplePatternItemsMultiple &&other) = default;
- TuplePatternItemsMultiple &operator= (TuplePatternItemsMultiple &&other)
+ TuplePatternItemsNoRest (TuplePatternItemsNoRest &&other) = default;
+ TuplePatternItemsNoRest &operator= (TuplePatternItemsNoRest &&other)
= default;
std::string as_string () const override;
return patterns;
}
- TuplePatternItemType get_pattern_type () const override
- {
- return TuplePatternItemType::MULTIPLE;
- }
+ ItemType get_item_type () const override { return ItemType::NO_REST; }
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
- TuplePatternItemsMultiple *clone_tuple_pattern_items_impl () const override
+ TuplePatternItemsNoRest *clone_pattern_items_impl () const override
{
- return new TuplePatternItemsMultiple (*this);
+ return new TuplePatternItemsNoRest (*this);
}
};
-// Class representing TuplePattern patterns where there are a range of patterns
-class TuplePatternItemsRanged : public TuplePatternItems
+// Class representing TuplePattern patterns which contains a rest pattern
+class TuplePatternItemsHasRest : public TuplePatternItems
{
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)
+ TuplePatternItemsHasRest (
+ 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))
{}
// Copy constructor with vector clone
- TuplePatternItemsRanged (TuplePatternItemsRanged const &other)
+ TuplePatternItemsHasRest (TuplePatternItemsHasRest const &other)
{
lower_patterns.reserve (other.lower_patterns.size ());
for (const auto &e : other.lower_patterns)
}
// Overloaded assignment operator to clone
- TuplePatternItemsRanged &operator= (TuplePatternItemsRanged const &other)
+ TuplePatternItemsHasRest &operator= (TuplePatternItemsHasRest const &other)
{
lower_patterns.clear ();
lower_patterns.reserve (other.lower_patterns.size ());
}
// move constructors
- TuplePatternItemsRanged (TuplePatternItemsRanged &&other) = default;
- TuplePatternItemsRanged &operator= (TuplePatternItemsRanged &&other)
+ TuplePatternItemsHasRest (TuplePatternItemsHasRest &&other) = default;
+ TuplePatternItemsHasRest &operator= (TuplePatternItemsHasRest &&other)
= default;
std::string as_string () const override;
return upper_patterns;
}
- TuplePatternItemType get_pattern_type () const override
- {
- return TuplePatternItemType::RANGED;
- }
+ ItemType get_item_type () const override { return ItemType::HAS_REST; }
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
- TuplePatternItemsRanged *clone_tuple_pattern_items_impl () const override
+ TuplePatternItemsHasRest *clone_pattern_items_impl () const override
{
- return new TuplePatternItemsRanged (*this);
+ return new TuplePatternItemsHasRest (*this);
}
};
};
// Base abstract class representing patterns in a SlicePattern
-class SlicePatternItems
+class SlicePatternItems : public PatternItems
{
public:
- enum SlicePatternItemType
- {
- NO_REST,
- HAS_REST,
- };
-
- virtual ~SlicePatternItems () {}
-
- // TODO: should this store location data?
-
// Unique pointer custom clone function
std::unique_ptr<SlicePatternItems> clone_slice_pattern_items () const
{
- return std::unique_ptr<SlicePatternItems> (
- clone_slice_pattern_items_impl ());
+ return std::unique_ptr<SlicePatternItems> (clone_pattern_items_impl ());
}
- virtual std::string as_string () const = 0;
-
- virtual void accept_vis (ASTVisitor &vis) = 0;
-
- virtual SlicePatternItemType get_pattern_type () const = 0;
-
protected:
// pure virtual clone implementation
- virtual SlicePatternItems *clone_slice_pattern_items_impl () const = 0;
+ virtual SlicePatternItems *clone_pattern_items_impl () const = 0;
};
// Class representing the patterns in a SlicePattern without `..`
return patterns;
}
- SlicePatternItemType get_pattern_type () const override
- {
- return SlicePatternItemType::NO_REST;
- }
+ ItemType get_item_type () const override { return ItemType::NO_REST; }
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
- SlicePatternItemsNoRest *clone_slice_pattern_items_impl () const override
+ SlicePatternItemsNoRest *clone_pattern_items_impl () const override
{
return new SlicePatternItemsNoRest (*this);
}
return upper_patterns;
}
- SlicePatternItemType get_pattern_type () const override
- {
- return SlicePatternItemType::HAS_REST;
- }
+ ItemType get_item_type () const override { return ItemType::HAS_REST; }
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
- SlicePatternItemsHasRest *clone_slice_pattern_items_impl () const override
+ SlicePatternItemsHasRest *clone_pattern_items_impl () const override
{
return new SlicePatternItemsHasRest (*this);
}
}
void
-CfgStrip::visit (AST::TupleStructItemsNoRange &tuple_items)
+CfgStrip::visit (AST::TupleStructItemsNoRest &tuple_items)
{
AST::DefaultASTVisitor::visit (tuple_items);
// can't strip individual patterns, only sub-patterns
}
}
void
-CfgStrip::visit (AST::TupleStructItemsRange &tuple_items)
+CfgStrip::visit (AST::TupleStructItemsHasRest &tuple_items)
{
AST::DefaultASTVisitor::visit (tuple_items);
// can't strip individual patterns, only sub-patterns
}
void
-CfgStrip::visit (AST::TuplePatternItemsMultiple &tuple_items)
+CfgStrip::visit (AST::TuplePatternItemsNoRest &tuple_items)
{
AST::DefaultASTVisitor::visit (tuple_items);
}
void
-CfgStrip::visit (AST::TuplePatternItemsRanged &tuple_items)
+CfgStrip::visit (AST::TuplePatternItemsHasRest &tuple_items)
{
AST::DefaultASTVisitor::visit (tuple_items);
void visit (AST::StructPatternFieldIdentPat &field) override;
void visit (AST::StructPatternFieldIdent &field) override;
void visit (AST::StructPattern &pattern) override;
- void visit (AST::TupleStructItemsNoRange &tuple_items) override;
- void visit (AST::TupleStructItemsRange &tuple_items) override;
+ void visit (AST::TupleStructItemsNoRest &tuple_items) override;
+ void visit (AST::TupleStructItemsHasRest &tuple_items) override;
void visit (AST::TupleStructPattern &pattern) override;
- void visit (AST::TuplePatternItemsMultiple &tuple_items) override;
- void visit (AST::TuplePatternItemsRanged &tuple_items) override;
+ void visit (AST::TuplePatternItemsNoRest &tuple_items) override;
+ void visit (AST::TuplePatternItemsHasRest &tuple_items) override;
void visit (AST::GroupedPattern &pattern) override;
void visit (AST::SlicePatternItemsNoRest &items) override;
void visit (AST::SlicePatternItemsHasRest &items) override;
}
auto pattern_items = std::unique_ptr<TupleStructItems> (
- new TupleStructItemsNoRange (std::move (patterns)));
+ new TupleStructItemsNoRest (std::move (patterns)));
auto pattern = std::unique_ptr<Pattern> (new ReferencePattern (
std::unique_ptr<Pattern> (new TupleStructPattern (
auto other_variant_path = builder.variant_path (enum_path, variant_path);
auto self_pattern_items = std::unique_ptr<TupleStructItems> (
- new TupleStructItemsNoRange (std::move (self_patterns)));
+ new TupleStructItemsNoRest (std::move (self_patterns)));
auto other_pattern_items = std::unique_ptr<TupleStructItems> (
- new TupleStructItemsNoRange (std::move (other_patterns)));
+ new TupleStructItemsNoRest (std::move (other_patterns)));
auto self_pattern = std::unique_ptr<Pattern> (
new ReferencePattern (std::unique_ptr<Pattern> (new TupleStructPattern (
other_variant_path, std::move (other_pattern_items))),
false, false, builder.loc));
- auto tuple_items = std::make_unique<TuplePatternItemsMultiple> (
+ auto tuple_items = std::make_unique<TuplePatternItemsNoRest> (
vec (std::move (self_pattern), std::move (other_pattern)));
auto pattern
std::move (other_elts))),
false, false, builder.loc));
- auto tuple_items = std::make_unique<TuplePatternItemsMultiple> (
+ auto tuple_items = std::make_unique<TuplePatternItemsNoRest> (
vec (std::move (self_pattern), std::move (other_pattern)));
auto pattern
}
auto patterns_elts = std::unique_ptr<TupleStructItems> (
- new TupleStructItemsNoRange (std::move (self_patterns)));
+ new TupleStructItemsNoRest (std::move (self_patterns)));
auto pattern = std::unique_ptr<Pattern> (
new ReferencePattern (std::unique_ptr<Pattern> (new TupleStructPattern (
variant_path, std::move (patterns_elts))),
if (ordering == Ordering::Partial)
{
auto pattern_items = std::unique_ptr<TupleStructItems> (
- new TupleStructItemsNoRange (vec (std::move (equal))));
+ new TupleStructItemsNoRest (vec (std::move (equal))));
equal
= std::make_unique<TupleStructPattern> (builder.path_in_expression (
builder.ref_pattern (
std::unique_ptr<Pattern> (new PathInExpression (variant_path))));
- auto tuple_items = std::make_unique<TuplePatternItemsMultiple> (
+ auto tuple_items = std::make_unique<TuplePatternItemsNoRest> (
std::move (inner_ref_patterns));
auto pattern = std::make_unique<TuplePattern> (std::move (tuple_items), loc);
}
auto self_pattern_items = std::unique_ptr<TupleStructItems> (
- new TupleStructItemsNoRange (std::move (self_patterns)));
+ new TupleStructItemsNoRest (std::move (self_patterns)));
auto other_pattern_items = std::unique_ptr<TupleStructItems> (
- new TupleStructItemsNoRange (std::move (other_patterns)));
+ new TupleStructItemsNoRest (std::move (other_patterns)));
auto self_pattern = std::unique_ptr<Pattern> (
new ReferencePattern (std::unique_ptr<Pattern> (new TupleStructPattern (
variant_path, std::move (other_pattern_items))),
false, false, loc));
- auto tuple_items = std::make_unique<TuplePatternItemsMultiple> (
+ auto tuple_items = std::make_unique<TuplePatternItemsNoRest> (
vec (std::move (self_pattern), std::move (other_pattern)));
auto pattern = std::make_unique<TuplePattern> (std::move (tuple_items), loc);
variant_path, loc, std::move (other_elts))),
false, false, loc));
- auto tuple_items = std::make_unique<TuplePatternItemsMultiple> (
+ auto tuple_items = std::make_unique<TuplePatternItemsNoRest> (
vec (std::move (self_pattern), std::move (other_pattern)));
auto pattern = std::make_unique<TuplePattern> (std::move (tuple_items), loc);
virtual void visit (StructPatternFieldIdentPat &field) override final{};
virtual void visit (StructPatternFieldIdent &field) override final{};
virtual void visit (StructPattern &pattern) override final{};
- virtual void visit (TupleStructItemsNoRange &tuple_items) override final{};
- virtual void visit (TupleStructItemsRange &tuple_items) override final{};
+ virtual void visit (TupleStructItemsNoRest &tuple_items) override final{};
+ virtual void visit (TupleStructItemsHasRest &tuple_items) override final{};
virtual void visit (TupleStructPattern &pattern) override final{};
- virtual void visit (TuplePatternItemsMultiple &tuple_items) override final{};
- virtual void visit (TuplePatternItemsRanged &tuple_items) override final{};
+ virtual void visit (TuplePatternItemsNoRest &tuple_items) override final{};
+ virtual void visit (TuplePatternItemsHasRest &tuple_items) override final{};
virtual void visit (TuplePattern &pattern) override final{};
virtual void visit (GroupedPattern &pattern) override final{};
virtual void visit (SlicePatternItemsNoRest &items) override final{};
} // namespace AST
} // namespace Rust
-#endif // DERIVE_VISITOR_H
+#endif // DERIVE_VISITOR_H
\ No newline at end of file
}
void
-ExpandVisitor::visit (AST::TupleStructItemsNoRange &tuple_items)
+ExpandVisitor::visit (AST::TupleStructItemsNoRest &tuple_items)
{
for (auto &sub : tuple_items.get_patterns ())
maybe_expand_pattern (sub);
}
void
-ExpandVisitor::visit (AST::TupleStructItemsRange &tuple_items)
+ExpandVisitor::visit (AST::TupleStructItemsHasRest &tuple_items)
{
for (auto &sub : tuple_items.get_lower_patterns ())
maybe_expand_pattern (sub);
}
void
-ExpandVisitor::visit (AST::TuplePatternItemsMultiple &tuple_items)
+ExpandVisitor::visit (AST::TuplePatternItemsNoRest &tuple_items)
{
for (auto &sub : tuple_items.get_patterns ())
maybe_expand_pattern (sub);
}
void
-ExpandVisitor::visit (AST::TuplePatternItemsRanged &tuple_items)
+ExpandVisitor::visit (AST::TuplePatternItemsHasRest &tuple_items)
{
for (auto &sub : tuple_items.get_lower_patterns ())
maybe_expand_pattern (sub);
void visit (AST::SlicePatternItemsNoRest &items) override;
void visit (AST::SlicePatternItemsHasRest &items) override;
void visit (AST::AltPattern &pattern) override;
- void visit (AST::TupleStructItemsNoRange &tuple_items) override;
- void visit (AST::TupleStructItemsRange &tuple_items) override;
- void visit (AST::TuplePatternItemsMultiple &tuple_items) override;
- void visit (AST::TuplePatternItemsRanged &tuple_items) override;
+ void visit (AST::TupleStructItemsNoRest &tuple_items) override;
+ void visit (AST::TupleStructItemsHasRest &tuple_items) override;
+ void visit (AST::TuplePatternItemsNoRest &tuple_items) override;
+ void visit (AST::TuplePatternItemsHasRest &tuple_items) override;
void visit (AST::LetStmt &stmt) override;
void visit (AST::ExprStmt &stmt) override;
{}
// void ASTLoweringBase::visit(TupleStructItemstuple_items) {}
void
-ASTLoweringBase::visit (AST::TupleStructItemsNoRange &)
+ASTLoweringBase::visit (AST::TupleStructItemsNoRest &)
{}
void
-ASTLoweringBase::visit (AST::TupleStructItemsRange &)
+ASTLoweringBase::visit (AST::TupleStructItemsHasRest &)
{}
void
ASTLoweringBase::visit (AST::TupleStructPattern &)
{}
// void ASTLoweringBase::visit(TuplePatternItemstuple_items) {}
void
-ASTLoweringBase::visit (AST::TuplePatternItemsMultiple &)
+ASTLoweringBase::visit (AST::TuplePatternItemsNoRest &)
{}
void
-ASTLoweringBase::visit (AST::TuplePatternItemsRanged &)
+ASTLoweringBase::visit (AST::TuplePatternItemsHasRest &)
{}
void
ASTLoweringBase::visit (AST::TuplePattern &)
std::unique_ptr<HIR::TuplePatternItems>
ASTLoweringBase::lower_tuple_pattern_multiple (
- AST::TuplePatternItemsMultiple &pattern)
+ AST::TuplePatternItemsNoRest &pattern)
{
std::vector<std::unique_ptr<HIR::Pattern>> patterns;
patterns.reserve (pattern.get_patterns ().size ());
std::unique_ptr<TuplePatternItems>
ASTLoweringBase::lower_tuple_pattern_ranged (
- AST::TuplePatternItemsRanged &pattern)
+ AST::TuplePatternItemsHasRest &pattern)
{
std::vector<std::unique_ptr<HIR::Pattern>> lower_patterns;
lower_patterns.reserve (pattern.get_lower_patterns ().size ());
virtual void visit (AST::StructPatternFieldIdent &field) override;
virtual void visit (AST::StructPattern &pattern) override;
// virtual void visit(TupleStructItems& tuple_items) override;
- virtual void visit (AST::TupleStructItemsNoRange &tuple_items) override;
- virtual void visit (AST::TupleStructItemsRange &tuple_items) override;
+ virtual void visit (AST::TupleStructItemsNoRest &tuple_items) override;
+ virtual void visit (AST::TupleStructItemsHasRest &tuple_items) override;
virtual void visit (AST::TupleStructPattern &pattern) override;
// virtual void visit(TuplePatternItems& tuple_items) override;
- virtual void visit (AST::TuplePatternItemsMultiple &tuple_items) override;
- virtual void visit (AST::TuplePatternItemsRanged &tuple_items) override;
+ virtual void visit (AST::TuplePatternItemsNoRest &tuple_items) override;
+ virtual void visit (AST::TuplePatternItemsHasRest &tuple_items) override;
virtual void visit (AST::TuplePattern &pattern) override;
virtual void visit (AST::GroupedPattern &pattern) override;
virtual void visit (AST::SlicePatternItemsNoRest &items) override;
attribute_handled_in_another_pass (const std::string &attribute_path) const;
std::unique_ptr<TuplePatternItems>
- lower_tuple_pattern_multiple (AST::TuplePatternItemsMultiple &pattern);
+ lower_tuple_pattern_multiple (AST::TuplePatternItemsNoRest &pattern);
std::unique_ptr<TuplePatternItems>
- lower_tuple_pattern_ranged (AST::TuplePatternItemsRanged &pattern);
+ lower_tuple_pattern_ranged (AST::TuplePatternItemsHasRest &pattern);
std::unique_ptr<SlicePatternItems>
lower_slice_pattern_no_rest (AST::SlicePatternItemsNoRest &pattern);
auto &items = pattern.get_items ();
switch (items.get_item_type ())
{
- case AST::TupleStructItems::RANGE:
+ case AST::TupleStructItems::HAS_REST:
{
// TODO
rust_unreachable ();
}
break;
- case AST::TupleStructItems::NO_RANGE:
+ case AST::TupleStructItems::NO_REST:
{
- AST::TupleStructItemsNoRange &items_no_range
- = static_cast<AST::TupleStructItemsNoRange &> (items);
+ AST::TupleStructItemsNoRest &items_no_range
+ = static_cast<AST::TupleStructItemsNoRest &> (items);
std::vector<std::unique_ptr<HIR::Pattern>> patterns;
patterns.reserve (items_no_range.get_patterns ().size ());
ASTLoweringPattern::visit (AST::TuplePattern &pattern)
{
std::unique_ptr<HIR::TuplePatternItems> items;
- switch (pattern.get_items ().get_pattern_type ())
+ switch (pattern.get_items ().get_item_type ())
{
- case AST::TuplePatternItems::TuplePatternItemType::MULTIPLE:
+ case AST::TuplePatternItems::ItemType::NO_REST:
{
- AST::TuplePatternItemsMultiple &ref
- = static_cast<AST::TuplePatternItemsMultiple &> (
- pattern.get_items ());
+ AST::TuplePatternItemsNoRest &ref
+ = static_cast<AST::TuplePatternItemsNoRest &> (pattern.get_items ());
items = lower_tuple_pattern_multiple (ref);
}
break;
- case AST::TuplePatternItems::TuplePatternItemType::RANGED:
+ case AST::TuplePatternItems::ItemType::HAS_REST:
{
- AST::TuplePatternItemsRanged &ref
- = static_cast<AST::TuplePatternItemsRanged &> (pattern.get_items ());
+ AST::TuplePatternItemsHasRest &ref
+ = static_cast<AST::TuplePatternItemsHasRest &> (pattern.get_items ());
items = lower_tuple_pattern_ranged (ref);
}
break;
{
std::unique_ptr<HIR::SlicePatternItems> items;
- switch (pattern.get_items ().get_pattern_type ())
+ switch (pattern.get_items ().get_item_type ())
{
- case AST::SlicePatternItems::SlicePatternItemType::NO_REST:
+ case AST::SlicePatternItems::ItemType::NO_REST:
{
auto &ref
= static_cast<AST::SlicePatternItemsNoRest &> (pattern.get_items ());
items = ASTLoweringBase::lower_slice_pattern_no_rest (ref);
}
break;
- case AST::SlicePatternItems::SlicePatternItemType::HAS_REST:
+ case AST::SlicePatternItems::ItemType::HAS_REST:
{
auto &ref
= static_cast<AST::SlicePatternItemsHasRest &> (pattern.get_items ());
// TODO: should this store location data?
// Unique pointer custom clone function
- std::unique_ptr<PatternItems> clone_tuple_items () const
+ std::unique_ptr<PatternItems> clone_pattern_items () const
{
return std::unique_ptr<PatternItems> (clone_pattern_items_impl ());
}
return nullptr;
}
- // create ranged tuple pattern items with only upper items
- std::unique_ptr<AST::TuplePatternItemsRanged> items (
- new AST::TuplePatternItemsRanged (
+ // create tuple pattern items with only upper pattern items
+ std::unique_ptr<AST::TuplePatternItemsHasRest> items (
+ new AST::TuplePatternItemsHasRest (
std::vector<std::unique_ptr<AST::Pattern>> (), std::move (patterns)));
return std::unique_ptr<AST::TuplePattern> (
new AST::TuplePattern (std::move (items), paren_locus));
else if (lexer.peek_token ()->get_id () == RIGHT_PAREN)
{
skip_token (RIGHT_PAREN);
- auto items = std::unique_ptr<AST::TuplePatternItemsMultiple> (
- new AST::TuplePatternItemsMultiple (
+ auto items = std::unique_ptr<AST::TuplePatternItemsNoRest> (
+ new AST::TuplePatternItemsNoRest (
std::vector<std::unique_ptr<AST::Pattern>> ()));
return std::unique_ptr<AST::TuplePattern> (
new AST::TuplePattern (std::move (items), paren_locus));
// non-ranged tuple pattern
lexer.skip_token ();
- std::unique_ptr<AST::TuplePatternItemsMultiple> items (
- new AST::TuplePatternItemsMultiple (std::move (patterns)));
+ std::unique_ptr<AST::TuplePatternItemsNoRest> items (
+ new AST::TuplePatternItemsNoRest (std::move (patterns)));
return std::unique_ptr<AST::TuplePattern> (
new AST::TuplePattern (std::move (items), paren_locus));
}
return nullptr;
}
- std::unique_ptr<AST::TuplePatternItemsRanged> items (
- new AST::TuplePatternItemsRanged (std::move (patterns),
- std::move (upper_patterns)));
+ std::unique_ptr<AST::TuplePatternItemsHasRest> items (
+ new AST::TuplePatternItemsHasRest (std::move (patterns),
+ std::move (upper_patterns)));
return std::unique_ptr<AST::TuplePattern> (
new AST::TuplePattern (std::move (items), paren_locus));
}
rust_debug (
"finished parsing tuple struct items ranged (upper/none only)");
- return std::unique_ptr<AST::TupleStructItemsRange> (
- new AST::TupleStructItemsRange (std::move (lower_patterns),
- std::move (upper_patterns)));
+ return std::unique_ptr<AST::TupleStructItemsHasRest> (
+ new AST::TupleStructItemsHasRest (std::move (lower_patterns),
+ std::move (upper_patterns)));
}
// has at least some lower patterns
switch (t->get_id ())
{
case RIGHT_PAREN:
- return std::unique_ptr<AST::TupleStructItemsNoRange> (
- new AST::TupleStructItemsNoRange (std::move (lower_patterns)));
+ return std::unique_ptr<AST::TupleStructItemsNoRest> (
+ new AST::TupleStructItemsNoRest (std::move (lower_patterns)));
case DOT_DOT:
{
// has an upper range that must be parsed separately
t = lexer.peek_token ();
}
- return std::unique_ptr<AST::TupleStructItemsRange> (
- new AST::TupleStructItemsRange (std::move (lower_patterns),
- std::move (upper_patterns)));
+ return std::unique_ptr<AST::TupleStructItemsHasRest> (
+ new AST::TupleStructItemsHasRest (std::move (lower_patterns),
+ std::move (upper_patterns)));
}
default:
// error
{}
void
-ResolverBase::visit (AST::TupleStructItemsNoRange &)
+ResolverBase::visit (AST::TupleStructItemsNoRest &)
{}
void
-ResolverBase::visit (AST::TupleStructItemsRange &)
+ResolverBase::visit (AST::TupleStructItemsHasRest &)
{}
void
{}
void
-ResolverBase::visit (AST::TuplePatternItemsMultiple &)
+ResolverBase::visit (AST::TuplePatternItemsNoRest &)
{}
void
-ResolverBase::visit (AST::TuplePatternItemsRanged &)
+ResolverBase::visit (AST::TuplePatternItemsHasRest &)
{}
void
void visit (AST::StructPatternFieldIdent &);
void visit (AST::StructPattern &);
- void visit (AST::TupleStructItemsNoRange &);
- void visit (AST::TupleStructItemsRange &);
+ void visit (AST::TupleStructItemsNoRest &);
+ void visit (AST::TupleStructItemsHasRest &);
void visit (AST::TupleStructPattern &);
- void visit (AST::TuplePatternItemsMultiple &);
- void visit (AST::TuplePatternItemsRanged &);
+ void visit (AST::TuplePatternItemsNoRest &);
+ void visit (AST::TuplePatternItemsHasRest &);
void visit (AST::TuplePattern &);
void visit (AST::GroupedPattern &);
void visit (AST::SlicePatternItemsNoRest &);
AST::TupleStructItems &items = pattern.get_items ();
switch (items.get_item_type ())
{
- case AST::TupleStructItems::RANGE:
+ case AST::TupleStructItems::HAS_REST:
{
// TODO
rust_unreachable ();
}
break;
- case AST::TupleStructItems::NO_RANGE:
+ case AST::TupleStructItems::NO_REST:
{
- auto &items_no_range
- = static_cast<AST::TupleStructItemsNoRange &> (items);
+ auto &items_no_rest
+ = static_cast<AST::TupleStructItemsNoRest &> (items);
- for (auto &inner_pattern : items_no_range.get_patterns ())
+ for (auto &inner_pattern : items_no_rest.get_patterns ())
{
inner_pattern->accept_vis (*this);
}
PatternDeclaration::visit (AST::TuplePattern &pattern)
{
auto &items = pattern.get_items ();
- switch (items.get_pattern_type ())
+ switch (items.get_item_type ())
{
- case AST::TuplePatternItems::TuplePatternItemType::MULTIPLE:
+ case AST::TuplePatternItems::ItemType::NO_REST:
{
- auto &ref = static_cast<AST::TuplePatternItemsMultiple &> (
- pattern.get_items ());
+ auto &ref
+ = static_cast<AST::TuplePatternItemsNoRest &> (pattern.get_items ());
for (auto &p : ref.get_patterns ())
p->accept_vis (*this);
}
break;
- case AST::TuplePatternItems::TuplePatternItemType::RANGED:
+ case AST::TuplePatternItems::ItemType::HAS_REST:
{
auto &ref
- = static_cast<AST::TuplePatternItemsRanged &> (pattern.get_items ());
+ = static_cast<AST::TuplePatternItemsHasRest &> (pattern.get_items ());
for (auto &p : ref.get_lower_patterns ())
p->accept_vis (*this);
PatternDeclaration::visit (AST::SlicePattern &pattern)
{
auto &items = pattern.get_items ();
- switch (items.get_pattern_type ())
+ switch (items.get_item_type ())
{
- case AST::SlicePatternItems::SlicePatternItemType::NO_REST:
+ case AST::SlicePatternItems::ItemType::NO_REST:
{
auto &ref
= static_cast<AST::SlicePatternItemsNoRest &> (pattern.get_items ());
}
break;
- case AST::SlicePatternItems::SlicePatternItemType::HAS_REST:
+ case AST::SlicePatternItems::ItemType::HAS_REST:
{
auto &ref
= static_cast<AST::SlicePatternItemsHasRest &> (pattern.get_items ());
// void AttributeChecker::visit(TupleStructItems& ){}
void
-AttributeChecker::visit (AST::TupleStructItemsNoRange &)
+AttributeChecker::visit (AST::TupleStructItemsNoRest &)
{}
void
-AttributeChecker::visit (AST::TupleStructItemsRange &)
+AttributeChecker::visit (AST::TupleStructItemsHasRest &)
{}
void
// void AttributeChecker::visit(TuplePatternItems& ){}
void
-AttributeChecker::visit (AST::TuplePatternItemsMultiple &)
+AttributeChecker::visit (AST::TuplePatternItemsNoRest &)
{}
void
-AttributeChecker::visit (AST::TuplePatternItemsRanged &)
+AttributeChecker::visit (AST::TuplePatternItemsHasRest &)
{}
void
void visit (AST::StructPatternFieldIdent &field) override;
void visit (AST::StructPattern &pattern) override;
// void visit(TupleStructItems& tuple_items) override;
- void visit (AST::TupleStructItemsNoRange &tuple_items) override;
- void visit (AST::TupleStructItemsRange &tuple_items) override;
+ void visit (AST::TupleStructItemsNoRest &tuple_items) override;
+ void visit (AST::TupleStructItemsHasRest &tuple_items) override;
void visit (AST::TupleStructPattern &pattern) override;
// void visit(TuplePatternItems& tuple_items) override;
- void visit (AST::TuplePatternItemsMultiple &tuple_items) override;
- void visit (AST::TuplePatternItemsRanged &tuple_items) override;
+ void visit (AST::TuplePatternItemsNoRest &tuple_items) override;
+ void visit (AST::TuplePatternItemsHasRest &tuple_items) override;
void visit (AST::TuplePattern &pattern) override;
void visit (AST::GroupedPattern &pattern) override;
void visit (AST::SlicePattern &pattern) override;
projects / thirdparty / gcc.git / commitdiff
