rustidy_ast/expr/without_block/
operator.rs

1//! Operator expression
2
3// Imports
4use {
5	crate::{expr::{Expression, ExpressionInner}, token, ty::TypeNoBounds},
6	super::{ExpressionWithoutBlockInner, Parse},
7	rustidy_format::{Format, Formattable, WhitespaceFormat},
8	rustidy_parse::{ParseRecursive, ParserTag},
9	rustidy_print::Print,
10	rustidy_util::Whitespace,
11};
12
13/// `OperatorExpression`
14#[derive(PartialEq, Eq, Clone, Debug)]
15#[derive(derive_more::From, derive_more::TryInto)]
16#[derive(serde::Serialize, serde::Deserialize)]
17#[derive(ParseRecursive, Formattable, Format, Print)]
18#[parse_recursive(root = ExpressionInner)]
19#[parse_recursive(into_root = ExpressionWithoutBlockInner)]
20pub enum OperatorExpression {
21	#[parse_recursive(recursive)]
22	LazyBoolean(LazyBooleanExpression),
23	#[parse_recursive(recursive)]
24	CompoundAssignment(CompoundAssignmentExpression),
25
26	#[parse_recursive(recursive)]
27	Borrow(BorrowExpression),
28	#[parse_recursive(recursive)]
29	Dereference(DereferenceExpression),
30	#[parse_recursive(recursive)]
31	TryPropagation(TryPropagationExpression),
32	#[parse_recursive(recursive)]
33	Negation(NegationExpression),
34	#[parse_recursive(recursive)]
35	ArithmeticOrLogical(ArithmeticOrLogicalExpression),
36	#[parse_recursive(recursive)]
37	Comparison(ComparisonExpression),
38	#[parse_recursive(recursive)]
39	TypeCast(TypeCastExpression),
40	#[parse_recursive(recursive)]
41	Assignment(AssignmentExpression),
42}
43
44/// `ErrorPropagationExpression`
45#[derive(PartialEq, Eq, Clone, Debug)]
46#[derive(serde::Serialize, serde::Deserialize)]
47#[derive(ParseRecursive, Formattable, Format, Print)]
48#[parse_recursive(root = ExpressionInner)]
49#[parse_recursive(into_root = OperatorExpression)]
50#[parse_recursive(kind = "left")]
51pub struct TryPropagationExpression {
52	pub expr:     Expression,
53	#[format(prefix_ws = Whitespace::REMOVE)]
54	pub question: token::Question,
55}
56
57/// `BorrowExpression`
58#[derive(PartialEq, Eq, Clone, Debug)]
59#[derive(serde::Serialize, serde::Deserialize)]
60#[derive(ParseRecursive, Formattable, Format, Print)]
61#[parse_recursive(root = ExpressionInner)]
62#[parse_recursive(into_root = OperatorExpression)]
63#[parse_recursive(kind = "right")]
64pub struct BorrowExpression {
65	pub ref_: BorrowExpressionKindRef,
66	#[format(prefix_ws = Whitespace::REMOVE)]
67	pub rest: Option<BorrowExpressionKindRest>,
68	#[format(prefix_ws = match self.rest.is_some() {
69		true => Whitespace::SINGLE,
70		false => Whitespace::REMOVE,
71	})]
72	pub expr: Expression,
73}
74
75#[derive(PartialEq, Eq, Clone, Debug)]
76#[derive(serde::Serialize, serde::Deserialize)]
77#[derive(Parse, Formattable, Format, Print)]
78pub enum BorrowExpressionKindRef {
79	And(token::And),
80	AndAnd(token::AndAnd),
81}
82
83#[derive(PartialEq, Eq, Clone, Debug)]
84#[derive(serde::Serialize, serde::Deserialize)]
85#[derive(Parse, Formattable, Format, Print)]
86pub enum BorrowExpressionKindRest {
87	Mut(token::Mut),
88	RawConst((token::Raw, token::Const)),
89	RawMut((token::Raw, token::Mut)),
90}
91
92/// `DereferenceExpression`
93#[derive(PartialEq, Eq, Clone, Debug)]
94#[derive(serde::Serialize, serde::Deserialize)]
95#[derive(ParseRecursive, Formattable, Format, Print)]
96#[parse_recursive(root = ExpressionInner)]
97#[parse_recursive(into_root = OperatorExpression)]
98#[parse_recursive(kind = "right")]
99pub struct DereferenceExpression {
100	pub star: token::Star,
101	#[format(prefix_ws = Whitespace::REMOVE)]
102	pub expr: Expression,
103}
104
105/// `NegationExpression`
106#[derive(PartialEq, Eq, Clone, Debug)]
107#[derive(serde::Serialize, serde::Deserialize)]
108#[derive(ParseRecursive, Formattable, Format, Print)]
109#[parse_recursive(root = ExpressionInner)]
110#[parse_recursive(into_root = OperatorExpression)]
111#[parse_recursive(kind = "right")]
112pub struct NegationExpression {
113	pub token: NegationExpressionToken,
114	#[format(prefix_ws = Whitespace::REMOVE)]
115	pub expr:  Expression,
116}
117
118#[derive(PartialEq, Eq, Clone, Debug)]
119#[derive(serde::Serialize, serde::Deserialize)]
120#[derive(Parse, Formattable, Format, Print)]
121pub enum NegationExpressionToken {
122	Minus(token::Minus),
123	Not(token::Not),
124}
125
126/// `ArithmeticOrLogicalExpression`
127#[derive(PartialEq, Eq, Clone, Debug)]
128#[derive(serde::Serialize, serde::Deserialize)]
129#[derive(ParseRecursive, Formattable, Format, Print)]
130#[parse_recursive(root = ExpressionInner)]
131#[parse_recursive(into_root = OperatorExpression)]
132#[parse_recursive(kind = "fully")]
133pub struct ArithmeticOrLogicalExpression {
134	pub lhs: Expression,
135	#[format(prefix_ws = Whitespace::SINGLE)]
136	pub op:  ArithmeticOrLogicalExpressionOp,
137	#[format(prefix_ws = Whitespace::SINGLE)]
138	pub rhs: Expression,
139}
140
141#[derive(PartialEq, Eq, Clone, Debug)]
142#[derive(serde::Serialize, serde::Deserialize)]
143#[derive(Parse, Formattable, Format, Print)]
144pub enum ArithmeticOrLogicalExpressionOp {
145	Plus(token::Plus),
146	Minus(token::Minus),
147	Star(token::Star),
148	Div(token::Slash),
149	Percent(token::Percent),
150	And(token::And),
151	Or(token::Or),
152	Caret(token::Caret),
153	Shl(token::Shl),
154	Shr(token::Shr),
155}
156
157/// `ComparisonExpression`
158#[derive(PartialEq, Eq, Clone, Debug)]
159#[derive(serde::Serialize, serde::Deserialize)]
160#[derive(ParseRecursive, Formattable, Format, Print)]
161#[parse_recursive(root = ExpressionInner)]
162#[parse_recursive(into_root = OperatorExpression)]
163#[parse_recursive(kind = "fully")]
164pub struct ComparisonExpression {
165	pub lhs: Expression,
166	#[format(prefix_ws = Whitespace::SINGLE)]
167	pub op:  ComparisonExpressionOp,
168	#[format(prefix_ws = Whitespace::SINGLE)]
169	pub rhs: Expression,
170}
171
172#[derive(PartialEq, Eq, Clone, Debug)]
173#[derive(serde::Serialize, serde::Deserialize)]
174#[derive(Parse, Formattable, Format, Print)]
175pub enum ComparisonExpressionOp {
176	EqEq(token::EqEq),
177	Ne(token::Ne),
178	Ge(token::Ge),
179	Le(token::Le),
180	Gt(token::Gt),
181	Lt(token::Lt),
182}
183
184/// `LazyBooleanExpression`
185#[derive(PartialEq, Eq, Clone, Debug)]
186#[derive(serde::Serialize, serde::Deserialize)]
187#[derive(ParseRecursive, Formattable, Format, Print)]
188#[parse_recursive(root = ExpressionInner)]
189#[parse_recursive(into_root = OperatorExpression)]
190#[parse_recursive(kind = "fully")]
191#[parse_recursive(skip_if_tag = ParserTag::SkipLazyBooleanExpression)]
192pub struct LazyBooleanExpression {
193	pub lhs: Expression,
194	#[format(prefix_ws = Whitespace::SINGLE)]
195	pub op:  LazyBooleanExpressionOp,
196	#[format(prefix_ws = Whitespace::SINGLE)]
197	pub rhs: Expression,
198}
199
200#[derive(PartialEq, Eq, Clone, Debug)]
201#[derive(serde::Serialize, serde::Deserialize)]
202#[derive(Parse, Formattable, Format, Print)]
203pub enum LazyBooleanExpressionOp {
204	Or(token::OrOr),
205	And(token::AndAnd),
206}
207
208/// `TypeCastExpression`
209#[derive(PartialEq, Eq, Clone, Debug)]
210#[derive(serde::Serialize, serde::Deserialize)]
211#[derive(ParseRecursive, Formattable, Format, Print)]
212#[parse_recursive(root = ExpressionInner)]
213#[parse_recursive(into_root = OperatorExpression)]
214#[parse_recursive(kind = "left")]
215pub struct TypeCastExpression {
216	pub lhs: Expression,
217	#[format(prefix_ws = Whitespace::SINGLE)]
218	pub as_: token::As,
219	#[format(prefix_ws = Whitespace::SINGLE)]
220	pub ty:  TypeNoBounds,
221}
222
223/// `AssignmentExpression`
224#[derive(PartialEq, Eq, Clone, Debug)]
225#[derive(serde::Serialize, serde::Deserialize)]
226#[derive(ParseRecursive, Formattable, Format, Print)]
227#[parse_recursive(root = ExpressionInner)]
228#[parse_recursive(into_root = OperatorExpression)]
229#[parse_recursive(kind = "fully")]
230#[parse_recursive(skip_if_tag = ParserTag::SkipAssignmentExpression)]
231pub struct AssignmentExpression {
232	pub lhs: Expression,
233	#[format(prefix_ws = Whitespace::SINGLE)]
234	pub eq:  token::Eq,
235	#[format(prefix_ws = Whitespace::SINGLE)]
236	pub rhs: Expression,
237}
238
239/// `CompoundAssignmentExpression`
240#[derive(PartialEq, Eq, Clone, Debug)]
241#[derive(serde::Serialize, serde::Deserialize)]
242#[derive(ParseRecursive, Formattable, Format, Print)]
243#[parse_recursive(root = ExpressionInner)]
244#[parse_recursive(into_root = OperatorExpression)]
245#[parse_recursive(kind = "fully")]
246#[parse_recursive(skip_if_tag = ParserTag::SkipCompoundAssignmentExpression)]
247pub struct CompoundAssignmentExpression {
248	pub lhs: Expression,
249	#[format(prefix_ws = Whitespace::SINGLE)]
250	pub op:  CompoundAssignmentExpressionOp,
251	#[format(prefix_ws = Whitespace::SINGLE)]
252	pub rhs: Expression,
253}
254
255#[derive(PartialEq, Eq, Clone, Debug)]
256#[derive(serde::Serialize, serde::Deserialize)]
257#[derive(Parse, Formattable, Format, Print)]
258pub enum CompoundAssignmentExpressionOp {
259	Plus(token::PlusEq),
260	Minus(token::MinusEq),
261	Star(token::StarEq),
262	Div(token::SlashEq),
263	Percent(token::PercentEq),
264	And(token::AndEq),
265	Or(token::OrEq),
266	Caret(token::CaretEq),
267	Shl(token::ShlEq),
268	Shr(token::ShrEq),
269}
rustidy_ast/expr/without_block/operator.rs

rustidy_ast/expr/without_block/
operator.rs
