Skip to content

Commit 25adf16

Browse files
CohenArthurCohenArthur
committed
ast: Cleanup SingleASTNode::NodeType
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.
1 parent 85ec714 commit 25adf16

4 files changed

Lines changed: 65 additions & 65 deletions

File tree

‎gcc/rust/ast/rust-ast-fragment.cc‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -107,26 +107,26 @@ Fragment::should_expand () const
107107
bool
108108
Fragment::is_expression_fragment () const
109109
{
110-
return is_single_fragment_of_kind (SingleASTNode::NodeType::EXPRESSION);
110+
return is_single_fragment_of_kind (SingleASTNode::Kind::Expr);
111111
}
112112

113113
bool
114114
Fragment::is_type_fragment () const
115115
{
116-
return is_single_fragment_of_kind (SingleASTNode::NodeType::TYPE);
116+
return is_single_fragment_of_kind (SingleASTNode::Kind::Type);
117117
}
118118

119119
std::unique_ptr<Expr>
120120
Fragment::take_expression_fragment ()
121121
{
122-
assert_single_fragment (SingleASTNode::NodeType::EXPRESSION);
122+
assert_single_fragment (SingleASTNode::Kind::Expr);
123123
return nodes[0].take_expr ();
124124
}
125125

126126
std::unique_ptr<Type>
127127
Fragment::take_type_fragment ()
128128
{
129-
assert_single_fragment (SingleASTNode::NodeType::TYPE);
129+
assert_single_fragment (SingleASTNode::Kind::Type);
130130
return nodes[0].take_type ();
131131
}
132132

@@ -144,21 +144,21 @@ Fragment::is_single_fragment () const
144144
}
145145

146146
bool
147-
Fragment::is_single_fragment_of_kind (SingleASTNode::NodeType expected) const
147+
Fragment::is_single_fragment_of_kind (SingleASTNode::Kind expected) const
148148
{
149149
return is_single_fragment () && nodes[0].get_kind () == expected;
150150
}
151151

152152
void
153-
Fragment::assert_single_fragment (SingleASTNode::NodeType expected) const
154-
{
155-
static const std::map<SingleASTNode::NodeType, const char *> str_map = {
156-
{SingleASTNode::NodeType::ASSOC_ITEM, "associated item"},
157-
{SingleASTNode::NodeType::ITEM, "item"},
158-
{SingleASTNode::NodeType::TYPE, "type"},
159-
{SingleASTNode::NodeType::EXPRESSION, "expr"},
160-
{SingleASTNode::NodeType::STMT, "stmt"},
161-
{SingleASTNode::NodeType::EXTERN, "extern"},
153+
Fragment::assert_single_fragment (SingleASTNode::Kind expected) const
154+
{
155+
static const std::map<SingleASTNode::Kind, const char *> str_map = {
156+
{SingleASTNode::Kind::Assoc, "associated item"},
157+
{SingleASTNode::Kind::Item, "item"},
158+
{SingleASTNode::Kind::Type, "type"},
159+
{SingleASTNode::Kind::Expr, "expr"},
160+
{SingleASTNode::Kind::Stmt, "stmt"},
161+
{SingleASTNode::Kind::Extern, "extern"},
162162
};
163163

164164
auto actual = nodes[0].get_kind ();

‎gcc/rust/ast/rust-ast-fragment.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -119,8 +119,8 @@ class Fragment
119119
* one Node will be extracted from the `nodes` vector
120120
*/
121121
bool is_single_fragment () const;
122-
bool is_single_fragment_of_kind (SingleASTNode::NodeType expected) const;
123-
void assert_single_fragment (SingleASTNode::NodeType expected) const;
122+
bool is_single_fragment_of_kind (SingleASTNode::Kind expected) const;
123+
void assert_single_fragment (SingleASTNode::Kind expected) const;
124124
};
125125

126126
enum class InvocKind

‎gcc/rust/ast/rust-ast.cc‎

Lines changed: 30 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -48,27 +48,27 @@ SingleASTNode::SingleASTNode (SingleASTNode const &other)
4848
kind = other.kind;
4949
switch (kind)
5050
{
51-
case EXPRESSION:
51+
case Kind::Expr:
5252
expr = other.expr->clone_expr ();
5353
break;
5454

55-
case ITEM:
55+
case Kind::Item:
5656
item = other.item->clone_item ();
5757
break;
5858

59-
case STMT:
59+
case Kind::Stmt:
6060
stmt = other.stmt->clone_stmt ();
6161
break;
6262

63-
case EXTERN:
63+
case Kind::Extern:
6464
external_item = other.external_item->clone_external_item ();
6565
break;
6666

67-
case ASSOC_ITEM:
67+
case Kind::Assoc:
6868
assoc_item = other.assoc_item->clone_associated_item ();
6969
break;
7070

71-
case TYPE:
71+
case Kind::Type:
7272
type = other.type->clone_type ();
7373
break;
7474
}
@@ -80,27 +80,27 @@ SingleASTNode::operator= (SingleASTNode const &other)
8080
kind = other.kind;
8181
switch (kind)
8282
{
83-
case EXPRESSION:
83+
case Kind::Expr:
8484
expr = other.expr->clone_expr ();
8585
break;
8686

87-
case ITEM:
87+
case Kind::Item:
8888
item = other.item->clone_item ();
8989
break;
9090

91-
case STMT:
91+
case Kind::Stmt:
9292
stmt = other.stmt->clone_stmt ();
9393
break;
9494

95-
case EXTERN:
95+
case Kind::Extern:
9696
external_item = other.external_item->clone_external_item ();
9797
break;
9898

99-
case ASSOC_ITEM:
99+
case Kind::Assoc:
100100
assoc_item = other.assoc_item->clone_associated_item ();
101101
break;
102102

103-
case TYPE:
103+
case Kind::Type:
104104
type = other.type->clone_type ();
105105
break;
106106
}
@@ -112,27 +112,27 @@ SingleASTNode::accept_vis (ASTVisitor &vis)
112112
{
113113
switch (kind)
114114
{
115-
case EXPRESSION:
115+
case Kind::Expr:
116116
expr->accept_vis (vis);
117117
break;
118118

119-
case ITEM:
119+
case Kind::Item:
120120
item->accept_vis (vis);
121121
break;
122122

123-
case STMT:
123+
case Kind::Stmt:
124124
stmt->accept_vis (vis);
125125
break;
126126

127-
case EXTERN:
127+
case Kind::Extern:
128128
external_item->accept_vis (vis);
129129
break;
130130

131-
case ASSOC_ITEM:
131+
case Kind::Assoc:
132132
assoc_item->accept_vis (vis);
133133
break;
134134

135-
case TYPE:
135+
case Kind::Type:
136136
type->accept_vis (vis);
137137
break;
138138
}
@@ -143,17 +143,17 @@ SingleASTNode::is_error ()
143143
{
144144
switch (kind)
145145
{
146-
case EXPRESSION:
146+
case Kind::Expr:
147147
return expr == nullptr;
148-
case ITEM:
148+
case Kind::Item:
149149
return item == nullptr;
150-
case STMT:
150+
case Kind::Stmt:
151151
return stmt == nullptr;
152-
case EXTERN:
152+
case Kind::Extern:
153153
return external_item == nullptr;
154-
case ASSOC_ITEM:
154+
case Kind::Assoc:
155155
return assoc_item == nullptr;
156-
case TYPE:
156+
case Kind::Type:
157157
return type == nullptr;
158158
}
159159

@@ -166,17 +166,17 @@ SingleASTNode::as_string () const
166166
{
167167
switch (kind)
168168
{
169-
case EXPRESSION:
169+
case Kind::Expr:
170170
return "Expr: " + expr->as_string ();
171-
case ITEM:
171+
case Kind::Item:
172172
return "Item: " + item->as_string ();
173-
case STMT:
173+
case Kind::Stmt:
174174
return "Stmt: " + stmt->as_string ();
175-
case EXTERN:
175+
case Kind::Extern:
176176
return "External Item: " + external_item->as_string ();
177-
case ASSOC_ITEM:
177+
case Kind::Assoc:
178178
return "Associated Item: " + assoc_item->as_string ();
179-
case TYPE:
179+
case Kind::Type:
180180
return "Type: " + type->as_string ();
181181
}
182182

‎gcc/rust/ast/rust-ast.h‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1957,18 +1957,18 @@ struct MacroInvocData
19571957
class SingleASTNode : public Visitable
19581958
{
19591959
public:
1960-
enum NodeType
1961-
{
1962-
EXPRESSION,
1963-
ITEM,
1964-
STMT,
1965-
EXTERN,
1966-
ASSOC_ITEM,
1967-
TYPE,
1960+
enum class Kind
1961+
{
1962+
Expr,
1963+
Item,
1964+
Stmt,
1965+
Extern,
1966+
Assoc,
1967+
Type,
19681968
};
19691969

19701970
private:
1971-
NodeType kind;
1971+
Kind kind;
19721972

19731973
// FIXME make this a union
19741974
std::unique_ptr<Expr> expr;
@@ -1980,27 +1980,27 @@ class SingleASTNode : public Visitable
19801980

19811981
public:
19821982
SingleASTNode (std::unique_ptr<Expr> expr)
1983-
: kind (EXPRESSION), expr (std::move (expr))
1983+
: kind (Kind::Expr), expr (std::move (expr))
19841984
{}
19851985

19861986
SingleASTNode (std::unique_ptr<Item> item)
1987-
: kind (ITEM), item (std::move (item))
1987+
: kind (Kind::Item), item (std::move (item))
19881988
{}
19891989

19901990
SingleASTNode (std::unique_ptr<Stmt> stmt)
1991-
: kind (STMT), stmt (std::move (stmt))
1991+
: kind (Kind::Stmt), stmt (std::move (stmt))
19921992
{}
19931993

19941994
SingleASTNode (std::unique_ptr<ExternalItem> item)
1995-
: kind (EXTERN), external_item (std::move (item))
1995+
: kind (Kind::Extern), external_item (std::move (item))
19961996
{}
19971997

19981998
SingleASTNode (std::unique_ptr<AssociatedItem> item)
1999-
: kind (ASSOC_ITEM), assoc_item (std::move (item))
1999+
: kind (Kind::Assoc), assoc_item (std::move (item))
20002000
{}
20012001

20022002
SingleASTNode (std::unique_ptr<Type> type)
2003-
: kind (TYPE), type (std::move (type))
2003+
: kind (Kind::Type), type (std::move (type))
20042004
{}
20052005

20062006
SingleASTNode (SingleASTNode const &other);
@@ -2010,23 +2010,23 @@ class SingleASTNode : public Visitable
20102010
SingleASTNode (SingleASTNode &&other) = default;
20112011
SingleASTNode &operator= (SingleASTNode &&other) = default;
20122012

2013-
NodeType get_kind () const { return kind; }
2013+
Kind get_kind () const { return kind; }
20142014

20152015
std::unique_ptr<Expr> &get_expr ()
20162016
{
2017-
rust_assert (kind == EXPRESSION);
2017+
rust_assert (kind == Kind::Expr);
20182018
return expr;
20192019
}
20202020

20212021
std::unique_ptr<Item> &get_item ()
20222022
{
2023-
rust_assert (kind == ITEM);
2023+
rust_assert (kind == Kind::Item);
20242024
return item;
20252025
}
20262026

20272027
std::unique_ptr<Stmt> &get_stmt ()
20282028
{
2029-
rust_assert (kind == STMT);
2029+
rust_assert (kind == Kind::Stmt);
20302030
return stmt;
20312031
}
20322032

0 commit comments

Comments
 (0)