From: Arthur Cohen <[email protected]>
gcc/rust/ChangeLog:
* ast/rust-ast.h: Change NodeType to enum class Kind.
* ast/rust-ast-fragment.cc: Use new names.
* ast/rust-ast-fragment.h: Likewise.
* ast/rust-ast.cc (SingleASTNode::SingleASTNode): Likewise.
---
gcc/rust/ast/rust-ast-fragment.cc | 28 +++++++--------
gcc/rust/ast/rust-ast-fragment.h | 4 +--
gcc/rust/ast/rust-ast.cc | 60 +++++++++++++++----------------
gcc/rust/ast/rust-ast.h | 38 ++++++++++----------
4 files changed, 65 insertions(+), 65 deletions(-)
diff --git a/gcc/rust/ast/rust-ast-fragment.cc
b/gcc/rust/ast/rust-ast-fragment.cc
index 076cab3234e..056fcac55b0 100644
--- a/gcc/rust/ast/rust-ast-fragment.cc
+++ b/gcc/rust/ast/rust-ast-fragment.cc
@@ -107,26 +107,26 @@ Fragment::should_expand () const
bool
Fragment::is_expression_fragment () const
{
- return is_single_fragment_of_kind (SingleASTNode::NodeType::EXPRESSION);
+ return is_single_fragment_of_kind (SingleASTNode::Kind::Expr);
}
bool
Fragment::is_type_fragment () const
{
- return is_single_fragment_of_kind (SingleASTNode::NodeType::TYPE);
+ return is_single_fragment_of_kind (SingleASTNode::Kind::Type);
}
std::unique_ptr<Expr>
Fragment::take_expression_fragment ()
{
- assert_single_fragment (SingleASTNode::NodeType::EXPRESSION);
+ assert_single_fragment (SingleASTNode::Kind::Expr);
return nodes[0].take_expr ();
}
std::unique_ptr<Type>
Fragment::take_type_fragment ()
{
- assert_single_fragment (SingleASTNode::NodeType::TYPE);
+ assert_single_fragment (SingleASTNode::Kind::Type);
return nodes[0].take_type ();
}
@@ -144,21 +144,21 @@ Fragment::is_single_fragment () const
}
bool
-Fragment::is_single_fragment_of_kind (SingleASTNode::NodeType expected) const
+Fragment::is_single_fragment_of_kind (SingleASTNode::Kind expected) const
{
return is_single_fragment () && nodes[0].get_kind () == expected;
}
void
-Fragment::assert_single_fragment (SingleASTNode::NodeType expected) const
-{
- static const std::map<SingleASTNode::NodeType, const char *> str_map = {
- {SingleASTNode::NodeType::ASSOC_ITEM, "associated item"},
- {SingleASTNode::NodeType::ITEM, "item"},
- {SingleASTNode::NodeType::TYPE, "type"},
- {SingleASTNode::NodeType::EXPRESSION, "expr"},
- {SingleASTNode::NodeType::STMT, "stmt"},
- {SingleASTNode::NodeType::EXTERN, "extern"},
+Fragment::assert_single_fragment (SingleASTNode::Kind expected) const
+{
+ static const std::map<SingleASTNode::Kind, const char *> str_map = {
+ {SingleASTNode::Kind::Assoc, "associated item"},
+ {SingleASTNode::Kind::Item, "item"},
+ {SingleASTNode::Kind::Type, "type"},
+ {SingleASTNode::Kind::Expr, "expr"},
+ {SingleASTNode::Kind::Stmt, "stmt"},
+ {SingleASTNode::Kind::Extern, "extern"},
};
auto actual = nodes[0].get_kind ();
diff --git a/gcc/rust/ast/rust-ast-fragment.h b/gcc/rust/ast/rust-ast-fragment.h
index 7d01fd7904f..d7584d0697c 100644
--- a/gcc/rust/ast/rust-ast-fragment.h
+++ b/gcc/rust/ast/rust-ast-fragment.h
@@ -119,8 +119,8 @@ private:
* one Node will be extracted from the `nodes` vector
*/
bool is_single_fragment () const;
- bool is_single_fragment_of_kind (SingleASTNode::NodeType expected) const;
- void assert_single_fragment (SingleASTNode::NodeType expected) const;
+ bool is_single_fragment_of_kind (SingleASTNode::Kind expected) const;
+ void assert_single_fragment (SingleASTNode::Kind expected) const;
};
enum class InvocKind
diff --git a/gcc/rust/ast/rust-ast.cc b/gcc/rust/ast/rust-ast.cc
index 8e856fb239f..c9b6fcef9d6 100644
--- a/gcc/rust/ast/rust-ast.cc
+++ b/gcc/rust/ast/rust-ast.cc
@@ -48,27 +48,27 @@ SingleASTNode::SingleASTNode (SingleASTNode const &other)
kind = other.kind;
switch (kind)
{
- case EXPRESSION:
+ case Kind::Expr:
expr = other.expr->clone_expr ();
break;
- case ITEM:
+ case Kind::Item:
item = other.item->clone_item ();
break;
- case STMT:
+ case Kind::Stmt:
stmt = other.stmt->clone_stmt ();
break;
- case EXTERN:
+ case Kind::Extern:
external_item = other.external_item->clone_external_item ();
break;
- case ASSOC_ITEM:
+ case Kind::Assoc:
assoc_item = other.assoc_item->clone_associated_item ();
break;
- case TYPE:
+ case Kind::Type:
type = other.type->clone_type ();
break;
}
@@ -80,27 +80,27 @@ SingleASTNode::operator= (SingleASTNode const &other)
kind = other.kind;
switch (kind)
{
- case EXPRESSION:
+ case Kind::Expr:
expr = other.expr->clone_expr ();
break;
- case ITEM:
+ case Kind::Item:
item = other.item->clone_item ();
break;
- case STMT:
+ case Kind::Stmt:
stmt = other.stmt->clone_stmt ();
break;
- case EXTERN:
+ case Kind::Extern:
external_item = other.external_item->clone_external_item ();
break;
- case ASSOC_ITEM:
+ case Kind::Assoc:
assoc_item = other.assoc_item->clone_associated_item ();
break;
- case TYPE:
+ case Kind::Type:
type = other.type->clone_type ();
break;
}
@@ -112,27 +112,27 @@ SingleASTNode::accept_vis (ASTVisitor &vis)
{
switch (kind)
{
- case EXPRESSION:
+ case Kind::Expr:
expr->accept_vis (vis);
break;
- case ITEM:
+ case Kind::Item:
item->accept_vis (vis);
break;
- case STMT:
+ case Kind::Stmt:
stmt->accept_vis (vis);
break;
- case EXTERN:
+ case Kind::Extern:
external_item->accept_vis (vis);
break;
- case ASSOC_ITEM:
+ case Kind::Assoc:
assoc_item->accept_vis (vis);
break;
- case TYPE:
+ case Kind::Type:
type->accept_vis (vis);
break;
}
@@ -143,17 +143,17 @@ SingleASTNode::is_error ()
{
switch (kind)
{
- case EXPRESSION:
+ case Kind::Expr:
return expr == nullptr;
- case ITEM:
+ case Kind::Item:
return item == nullptr;
- case STMT:
+ case Kind::Stmt:
return stmt == nullptr;
- case EXTERN:
+ case Kind::Extern:
return external_item == nullptr;
- case ASSOC_ITEM:
+ case Kind::Assoc:
return assoc_item == nullptr;
- case TYPE:
+ case Kind::Type:
return type == nullptr;
}
@@ -166,17 +166,17 @@ SingleASTNode::as_string () const
{
switch (kind)
{
- case EXPRESSION:
+ case Kind::Expr:
return "Expr: " + expr->as_string ();
- case ITEM:
+ case Kind::Item:
return "Item: " + item->as_string ();
- case STMT:
+ case Kind::Stmt:
return "Stmt: " + stmt->as_string ();
- case EXTERN:
+ case Kind::Extern:
return "External Item: " + external_item->as_string ();
- case ASSOC_ITEM:
+ case Kind::Assoc:
return "Associated Item: " + assoc_item->as_string ();
- case TYPE:
+ case Kind::Type:
return "Type: " + type->as_string ();
}
diff --git a/gcc/rust/ast/rust-ast.h b/gcc/rust/ast/rust-ast.h
index 0feaf514105..148e297c543 100644
--- a/gcc/rust/ast/rust-ast.h
+++ b/gcc/rust/ast/rust-ast.h
@@ -1962,18 +1962,18 @@ public:
class SingleASTNode : public Visitable
{
public:
- enum NodeType
- {
- EXPRESSION,
- ITEM,
- STMT,
- EXTERN,
- ASSOC_ITEM,
- TYPE,
+ enum class Kind
+ {
+ Expr,
+ Item,
+ Stmt,
+ Extern,
+ Assoc,
+ Type,
};
private:
- NodeType kind;
+ Kind kind;
// FIXME make this a union
std::unique_ptr<Expr> expr;
@@ -1985,27 +1985,27 @@ private:
public:
SingleASTNode (std::unique_ptr<Expr> expr)
- : kind (EXPRESSION), expr (std::move (expr))
+ : kind (Kind::Expr), expr (std::move (expr))
{}
SingleASTNode (std::unique_ptr<Item> item)
- : kind (ITEM), item (std::move (item))
+ : kind (Kind::Item), item (std::move (item))
{}
SingleASTNode (std::unique_ptr<Stmt> stmt)
- : kind (STMT), stmt (std::move (stmt))
+ : kind (Kind::Stmt), stmt (std::move (stmt))
{}
SingleASTNode (std::unique_ptr<ExternalItem> item)
- : kind (EXTERN), external_item (std::move (item))
+ : kind (Kind::Extern), external_item (std::move (item))
{}
SingleASTNode (std::unique_ptr<AssociatedItem> item)
- : kind (ASSOC_ITEM), assoc_item (std::move (item))
+ : kind (Kind::Assoc), assoc_item (std::move (item))
{}
SingleASTNode (std::unique_ptr<Type> type)
- : kind (TYPE), type (std::move (type))
+ : kind (Kind::Type), type (std::move (type))
{}
SingleASTNode (SingleASTNode const &other);
@@ -2015,23 +2015,23 @@ public:
SingleASTNode (SingleASTNode &&other) = default;
SingleASTNode &operator= (SingleASTNode &&other) = default;
- NodeType get_kind () const { return kind; }
+ Kind get_kind () const { return kind; }
std::unique_ptr<Expr> &get_expr ()
{
- rust_assert (kind == EXPRESSION);
+ rust_assert (kind == Kind::Expr);
return expr;
}
std::unique_ptr<Item> &get_item ()
{
- rust_assert (kind == ITEM);
+ rust_assert (kind == Kind::Item);
return item;
}
std::unique_ptr<Stmt> &get_stmt ()
{
- rust_assert (kind == STMT);
+ rust_assert (kind == Kind::Stmt);
return stmt;
}
--
2.50.1
