syn/
op.rs

1// SPDX-License-Identifier: Apache-2.0 OR MIT
2
3ast_enum! {
4    /// A binary operator: `+`, `+=`, `&`.
5    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
6    #[non_exhaustive]
7    pub enum BinOp {
8        /// The `+` operator (addition)
9        Add(Token![+]),
10        /// The `-` operator (subtraction)
11        Sub(Token![-]),
12        /// The `*` operator (multiplication)
13        Mul(Token![*]),
14        /// The `/` operator (division)
15        Div(Token![/]),
16        /// The `%` operator (modulus)
17        Rem(Token![%]),
18        /// The `&&` operator (logical and)
19        And(Token![&&]),
20        /// The `||` operator (logical or)
21        Or(Token![||]),
22        /// The `^` operator (bitwise xor)
23        BitXor(Token![^]),
24        /// The `&` operator (bitwise and)
25        BitAnd(Token![&]),
26        /// The `|` operator (bitwise or)
27        BitOr(Token![|]),
28        /// The `<<` operator (shift left)
29        Shl(Token![<<]),
30        /// The `>>` operator (shift right)
31        Shr(Token![>>]),
32        /// The `==` operator (equality)
33        Eq(Token![==]),
34        /// The `<` operator (less than)
35        Lt(Token![<]),
36        /// The `<=` operator (less than or equal to)
37        Le(Token![<=]),
38        /// The `!=` operator (not equal to)
39        Ne(Token![!=]),
40        /// The `>=` operator (greater than or equal to)
41        Ge(Token![>=]),
42        /// The `>` operator (greater than)
43        Gt(Token![>]),
44        /// The `+=` operator
45        AddAssign(Token![+=]),
46        /// The `-=` operator
47        SubAssign(Token![-=]),
48        /// The `*=` operator
49        MulAssign(Token![*=]),
50        /// The `/=` operator
51        DivAssign(Token![/=]),
52        /// The `%=` operator
53        RemAssign(Token![%=]),
54        /// The `^=` operator
55        BitXorAssign(Token![^=]),
56        /// The `&=` operator
57        BitAndAssign(Token![&=]),
58        /// The `|=` operator
59        BitOrAssign(Token![|=]),
60        /// The `<<=` operator
61        ShlAssign(Token![<<=]),
62        /// The `>>=` operator
63        ShrAssign(Token![>>=]),
64    }
65}
66
67ast_enum! {
68    /// A unary operator: `*`, `!`, `-`.
69    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
70    #[non_exhaustive]
71    pub enum UnOp {
72        /// The `*` operator for dereferencing
73        Deref(Token![*]),
74        /// The `!` operator for logical inversion
75        Not(Token![!]),
76        /// The `-` operator for negation
77        Neg(Token![-]),
78    }
79}
80
81#[cfg(feature = "parsing")]
82pub(crate) mod parsing {
83    use crate::error::Result;
84    use crate::op::{BinOp, UnOp};
85    use crate::parse::{Parse, ParseStream};
86
87    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
88    impl Parse for BinOp {
89        fn parse(input: ParseStream) -> Result<Self> {
90            if input.peek(Token![+=]) {
91                input.parse().map(BinOp::AddAssign)
92            } else if input.peek(Token![-=]) {
93                input.parse().map(BinOp::SubAssign)
94            } else if input.peek(Token![*=]) {
95                input.parse().map(BinOp::MulAssign)
96            } else if input.peek(Token![/=]) {
97                input.parse().map(BinOp::DivAssign)
98            } else if input.peek(Token![%=]) {
99                input.parse().map(BinOp::RemAssign)
100            } else if input.peek(Token![^=]) {
101                input.parse().map(BinOp::BitXorAssign)
102            } else if input.peek(Token![&=]) {
103                input.parse().map(BinOp::BitAndAssign)
104            } else if input.peek(Token![|=]) {
105                input.parse().map(BinOp::BitOrAssign)
106            } else if input.peek(Token![<<=]) {
107                input.parse().map(BinOp::ShlAssign)
108            } else if input.peek(Token![>>=]) {
109                input.parse().map(BinOp::ShrAssign)
110            } else if input.peek(Token![&&]) {
111                input.parse().map(BinOp::And)
112            } else if input.peek(Token![||]) {
113                input.parse().map(BinOp::Or)
114            } else if input.peek(Token![<<]) {
115                input.parse().map(BinOp::Shl)
116            } else if input.peek(Token![>>]) {
117                input.parse().map(BinOp::Shr)
118            } else if input.peek(Token![==]) {
119                input.parse().map(BinOp::Eq)
120            } else if input.peek(Token![<=]) {
121                input.parse().map(BinOp::Le)
122            } else if input.peek(Token![!=]) {
123                input.parse().map(BinOp::Ne)
124            } else if input.peek(Token![>=]) {
125                input.parse().map(BinOp::Ge)
126            } else if input.peek(Token![+]) {
127                input.parse().map(BinOp::Add)
128            } else if input.peek(Token![-]) {
129                input.parse().map(BinOp::Sub)
130            } else if input.peek(Token![*]) {
131                input.parse().map(BinOp::Mul)
132            } else if input.peek(Token![/]) {
133                input.parse().map(BinOp::Div)
134            } else if input.peek(Token![%]) {
135                input.parse().map(BinOp::Rem)
136            } else if input.peek(Token![^]) {
137                input.parse().map(BinOp::BitXor)
138            } else if input.peek(Token![&]) {
139                input.parse().map(BinOp::BitAnd)
140            } else if input.peek(Token![|]) {
141                input.parse().map(BinOp::BitOr)
142            } else if input.peek(Token![<]) {
143                input.parse().map(BinOp::Lt)
144            } else if input.peek(Token![>]) {
145                input.parse().map(BinOp::Gt)
146            } else {
147                Err(input.error("expected binary operator"))
148            }
149        }
150    }
151
152    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
153    impl Parse for UnOp {
154        fn parse(input: ParseStream) -> Result<Self> {
155            let lookahead = input.lookahead1();
156            if lookahead.peek(Token![*]) {
157                input.parse().map(UnOp::Deref)
158            } else if lookahead.peek(Token![!]) {
159                input.parse().map(UnOp::Not)
160            } else if lookahead.peek(Token![-]) {
161                input.parse().map(UnOp::Neg)
162            } else {
163                Err(lookahead.error())
164            }
165        }
166    }
167}
168
169#[cfg(feature = "printing")]
170mod printing {
171    use crate::op::{BinOp, UnOp};
172    use proc_macro2::TokenStream;
173    use quote::ToTokens;
174
175    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
176    impl ToTokens for BinOp {
177        fn to_tokens(&self, tokens: &mut TokenStream) {
178            match self {
179                BinOp::Add(t) => t.to_tokens(tokens),
180                BinOp::Sub(t) => t.to_tokens(tokens),
181                BinOp::Mul(t) => t.to_tokens(tokens),
182                BinOp::Div(t) => t.to_tokens(tokens),
183                BinOp::Rem(t) => t.to_tokens(tokens),
184                BinOp::And(t) => t.to_tokens(tokens),
185                BinOp::Or(t) => t.to_tokens(tokens),
186                BinOp::BitXor(t) => t.to_tokens(tokens),
187                BinOp::BitAnd(t) => t.to_tokens(tokens),
188                BinOp::BitOr(t) => t.to_tokens(tokens),
189                BinOp::Shl(t) => t.to_tokens(tokens),
190                BinOp::Shr(t) => t.to_tokens(tokens),
191                BinOp::Eq(t) => t.to_tokens(tokens),
192                BinOp::Lt(t) => t.to_tokens(tokens),
193                BinOp::Le(t) => t.to_tokens(tokens),
194                BinOp::Ne(t) => t.to_tokens(tokens),
195                BinOp::Ge(t) => t.to_tokens(tokens),
196                BinOp::Gt(t) => t.to_tokens(tokens),
197                BinOp::AddAssign(t) => t.to_tokens(tokens),
198                BinOp::SubAssign(t) => t.to_tokens(tokens),
199                BinOp::MulAssign(t) => t.to_tokens(tokens),
200                BinOp::DivAssign(t) => t.to_tokens(tokens),
201                BinOp::RemAssign(t) => t.to_tokens(tokens),
202                BinOp::BitXorAssign(t) => t.to_tokens(tokens),
203                BinOp::BitAndAssign(t) => t.to_tokens(tokens),
204                BinOp::BitOrAssign(t) => t.to_tokens(tokens),
205                BinOp::ShlAssign(t) => t.to_tokens(tokens),
206                BinOp::ShrAssign(t) => t.to_tokens(tokens),
207            }
208        }
209    }
210
211    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
212    impl ToTokens for UnOp {
213        fn to_tokens(&self, tokens: &mut TokenStream) {
214            match self {
215                UnOp::Deref(t) => t.to_tokens(tokens),
216                UnOp::Not(t) => t.to_tokens(tokens),
217                UnOp::Neg(t) => t.to_tokens(tokens),
218            }
219        }
220    }
221}
syn/op.rs

syn/
op.rs
