aboutsummaryrefslogtreecommitdiff
path: root/vendor/syn/src/op.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/syn/src/op.rs')
-rw-r--r--vendor/syn/src/op.rs218
1 files changed, 0 insertions, 218 deletions
diff --git a/vendor/syn/src/op.rs b/vendor/syn/src/op.rs
deleted file mode 100644
index c231285..0000000
--- a/vendor/syn/src/op.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-ast_enum! {
- /// A binary operator: `+`, `+=`, `&`.
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- #[non_exhaustive]
- pub enum BinOp {
- /// The `+` operator (addition)
- Add(Token![+]),
- /// The `-` operator (subtraction)
- Sub(Token![-]),
- /// The `*` operator (multiplication)
- Mul(Token![*]),
- /// The `/` operator (division)
- Div(Token![/]),
- /// The `%` operator (modulus)
- Rem(Token![%]),
- /// The `&&` operator (logical and)
- And(Token![&&]),
- /// The `||` operator (logical or)
- Or(Token![||]),
- /// The `^` operator (bitwise xor)
- BitXor(Token![^]),
- /// The `&` operator (bitwise and)
- BitAnd(Token![&]),
- /// The `|` operator (bitwise or)
- BitOr(Token![|]),
- /// The `<<` operator (shift left)
- Shl(Token![<<]),
- /// The `>>` operator (shift right)
- Shr(Token![>>]),
- /// The `==` operator (equality)
- Eq(Token![==]),
- /// The `<` operator (less than)
- Lt(Token![<]),
- /// The `<=` operator (less than or equal to)
- Le(Token![<=]),
- /// The `!=` operator (not equal to)
- Ne(Token![!=]),
- /// The `>=` operator (greater than or equal to)
- Ge(Token![>=]),
- /// The `>` operator (greater than)
- Gt(Token![>]),
- /// The `+=` operator
- AddAssign(Token![+=]),
- /// The `-=` operator
- SubAssign(Token![-=]),
- /// The `*=` operator
- MulAssign(Token![*=]),
- /// The `/=` operator
- DivAssign(Token![/=]),
- /// The `%=` operator
- RemAssign(Token![%=]),
- /// The `^=` operator
- BitXorAssign(Token![^=]),
- /// The `&=` operator
- BitAndAssign(Token![&=]),
- /// The `|=` operator
- BitOrAssign(Token![|=]),
- /// The `<<=` operator
- ShlAssign(Token![<<=]),
- /// The `>>=` operator
- ShrAssign(Token![>>=]),
- }
-}
-
-ast_enum! {
- /// A unary operator: `*`, `!`, `-`.
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- #[non_exhaustive]
- pub enum UnOp {
- /// The `*` operator for dereferencing
- Deref(Token![*]),
- /// The `!` operator for logical inversion
- Not(Token![!]),
- /// The `-` operator for negation
- Neg(Token![-]),
- }
-}
-
-#[cfg(feature = "parsing")]
-pub(crate) mod parsing {
- use super::*;
- use crate::parse::{Parse, ParseStream, Result};
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- impl Parse for BinOp {
- fn parse(input: ParseStream) -> Result<Self> {
- if input.peek(Token![+=]) {
- input.parse().map(BinOp::AddAssign)
- } else if input.peek(Token![-=]) {
- input.parse().map(BinOp::SubAssign)
- } else if input.peek(Token![*=]) {
- input.parse().map(BinOp::MulAssign)
- } else if input.peek(Token![/=]) {
- input.parse().map(BinOp::DivAssign)
- } else if input.peek(Token![%=]) {
- input.parse().map(BinOp::RemAssign)
- } else if input.peek(Token![^=]) {
- input.parse().map(BinOp::BitXorAssign)
- } else if input.peek(Token![&=]) {
- input.parse().map(BinOp::BitAndAssign)
- } else if input.peek(Token![|=]) {
- input.parse().map(BinOp::BitOrAssign)
- } else if input.peek(Token![<<=]) {
- input.parse().map(BinOp::ShlAssign)
- } else if input.peek(Token![>>=]) {
- input.parse().map(BinOp::ShrAssign)
- } else if input.peek(Token![&&]) {
- input.parse().map(BinOp::And)
- } else if input.peek(Token![||]) {
- input.parse().map(BinOp::Or)
- } else if input.peek(Token![<<]) {
- input.parse().map(BinOp::Shl)
- } else if input.peek(Token![>>]) {
- input.parse().map(BinOp::Shr)
- } else if input.peek(Token![==]) {
- input.parse().map(BinOp::Eq)
- } else if input.peek(Token![<=]) {
- input.parse().map(BinOp::Le)
- } else if input.peek(Token![!=]) {
- input.parse().map(BinOp::Ne)
- } else if input.peek(Token![>=]) {
- input.parse().map(BinOp::Ge)
- } else if input.peek(Token![+]) {
- input.parse().map(BinOp::Add)
- } else if input.peek(Token![-]) {
- input.parse().map(BinOp::Sub)
- } else if input.peek(Token![*]) {
- input.parse().map(BinOp::Mul)
- } else if input.peek(Token![/]) {
- input.parse().map(BinOp::Div)
- } else if input.peek(Token![%]) {
- input.parse().map(BinOp::Rem)
- } else if input.peek(Token![^]) {
- input.parse().map(BinOp::BitXor)
- } else if input.peek(Token![&]) {
- input.parse().map(BinOp::BitAnd)
- } else if input.peek(Token![|]) {
- input.parse().map(BinOp::BitOr)
- } else if input.peek(Token![<]) {
- input.parse().map(BinOp::Lt)
- } else if input.peek(Token![>]) {
- input.parse().map(BinOp::Gt)
- } else {
- Err(input.error("expected binary operator"))
- }
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- impl Parse for UnOp {
- fn parse(input: ParseStream) -> Result<Self> {
- let lookahead = input.lookahead1();
- if lookahead.peek(Token![*]) {
- input.parse().map(UnOp::Deref)
- } else if lookahead.peek(Token![!]) {
- input.parse().map(UnOp::Not)
- } else if lookahead.peek(Token![-]) {
- input.parse().map(UnOp::Neg)
- } else {
- Err(lookahead.error())
- }
- }
- }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
- use super::*;
- use proc_macro2::TokenStream;
- use quote::ToTokens;
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for BinOp {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- match self {
- BinOp::Add(t) => t.to_tokens(tokens),
- BinOp::Sub(t) => t.to_tokens(tokens),
- BinOp::Mul(t) => t.to_tokens(tokens),
- BinOp::Div(t) => t.to_tokens(tokens),
- BinOp::Rem(t) => t.to_tokens(tokens),
- BinOp::And(t) => t.to_tokens(tokens),
- BinOp::Or(t) => t.to_tokens(tokens),
- BinOp::BitXor(t) => t.to_tokens(tokens),
- BinOp::BitAnd(t) => t.to_tokens(tokens),
- BinOp::BitOr(t) => t.to_tokens(tokens),
- BinOp::Shl(t) => t.to_tokens(tokens),
- BinOp::Shr(t) => t.to_tokens(tokens),
- BinOp::Eq(t) => t.to_tokens(tokens),
- BinOp::Lt(t) => t.to_tokens(tokens),
- BinOp::Le(t) => t.to_tokens(tokens),
- BinOp::Ne(t) => t.to_tokens(tokens),
- BinOp::Ge(t) => t.to_tokens(tokens),
- BinOp::Gt(t) => t.to_tokens(tokens),
- BinOp::AddAssign(t) => t.to_tokens(tokens),
- BinOp::SubAssign(t) => t.to_tokens(tokens),
- BinOp::MulAssign(t) => t.to_tokens(tokens),
- BinOp::DivAssign(t) => t.to_tokens(tokens),
- BinOp::RemAssign(t) => t.to_tokens(tokens),
- BinOp::BitXorAssign(t) => t.to_tokens(tokens),
- BinOp::BitAndAssign(t) => t.to_tokens(tokens),
- BinOp::BitOrAssign(t) => t.to_tokens(tokens),
- BinOp::ShlAssign(t) => t.to_tokens(tokens),
- BinOp::ShrAssign(t) => t.to_tokens(tokens),
- }
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for UnOp {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- match self {
- UnOp::Deref(t) => t.to_tokens(tokens),
- UnOp::Not(t) => t.to_tokens(tokens),
- UnOp::Neg(t) => t.to_tokens(tokens),
- }
- }
- }
-}
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.