File Index
Files and directories
Sign in
FILE

eq.rs

File preview with syntax highlighting.

linux-6.19.14/rust/syn/gen/eq.rs RUST
   1// SPDX-License-Identifier: Apache-2.0 OR MIT
   2
   3// This file is @generated by syn-internal-codegen.
   4// It is not intended for manual editing.
   5
   6#[cfg(any(feature = "derive", feature = "full"))]
   7use crate::tt::TokenStreamHelper;
   8#[cfg(any(feature = "derive", feature = "full"))]
   9#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  10impl Eq for crate::Abi {}
  11#[cfg(any(feature = "derive", feature = "full"))]
  12#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  13impl PartialEq for crate::Abi {
  14    fn eq(&self, other: &Self) -> bool {
  15        self.name == other.name
  16    }
  17}
  18#[cfg(any(feature = "derive", feature = "full"))]
  19#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  20impl Eq for crate::AngleBracketedGenericArguments {}
  21#[cfg(any(feature = "derive", feature = "full"))]
  22#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  23impl PartialEq for crate::AngleBracketedGenericArguments {
  24    fn eq(&self, other: &Self) -> bool {
  25        self.colon2_token == other.colon2_token && self.args == other.args
  26    }
  27}
  28#[cfg(feature = "full")]
  29#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  30impl Eq for crate::Arm {}
  31#[cfg(feature = "full")]
  32#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  33impl PartialEq for crate::Arm {
  34    fn eq(&self, other: &Self) -> bool {
  35        self.attrs == other.attrs && self.pat == other.pat && self.guard == other.guard
  36            && self.body == other.body && self.comma == other.comma
  37    }
  38}
  39#[cfg(any(feature = "derive", feature = "full"))]
  40#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  41impl Eq for crate::AssocConst {}
  42#[cfg(any(feature = "derive", feature = "full"))]
  43#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  44impl PartialEq for crate::AssocConst {
  45    fn eq(&self, other: &Self) -> bool {
  46        self.ident == other.ident && self.generics == other.generics
  47            && self.value == other.value
  48    }
  49}
  50#[cfg(any(feature = "derive", feature = "full"))]
  51#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  52impl Eq for crate::AssocType {}
  53#[cfg(any(feature = "derive", feature = "full"))]
  54#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  55impl PartialEq for crate::AssocType {
  56    fn eq(&self, other: &Self) -> bool {
  57        self.ident == other.ident && self.generics == other.generics
  58            && self.ty == other.ty
  59    }
  60}
  61#[cfg(any(feature = "derive", feature = "full"))]
  62#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  63impl Eq for crate::AttrStyle {}
  64#[cfg(any(feature = "derive", feature = "full"))]
  65#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  66impl PartialEq for crate::AttrStyle {
  67    fn eq(&self, other: &Self) -> bool {
  68        match (self, other) {
  69            (crate::AttrStyle::Outer, crate::AttrStyle::Outer) => true,
  70            (crate::AttrStyle::Inner(_), crate::AttrStyle::Inner(_)) => true,
  71            _ => false,
  72        }
  73    }
  74}
  75#[cfg(any(feature = "derive", feature = "full"))]
  76#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  77impl Eq for crate::Attribute {}
  78#[cfg(any(feature = "derive", feature = "full"))]
  79#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  80impl PartialEq for crate::Attribute {
  81    fn eq(&self, other: &Self) -> bool {
  82        self.style == other.style && self.meta == other.meta
  83    }
  84}
  85#[cfg(any(feature = "derive", feature = "full"))]
  86#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  87impl Eq for crate::BareFnArg {}
  88#[cfg(any(feature = "derive", feature = "full"))]
  89#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  90impl PartialEq for crate::BareFnArg {
  91    fn eq(&self, other: &Self) -> bool {
  92        self.attrs == other.attrs && self.name == other.name && self.ty == other.ty
  93    }
  94}
  95#[cfg(any(feature = "derive", feature = "full"))]
  96#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
  97impl Eq for crate::BareVariadic {}
  98#[cfg(any(feature = "derive", feature = "full"))]
  99#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 100impl PartialEq for crate::BareVariadic {
 101    fn eq(&self, other: &Self) -> bool {
 102        self.attrs == other.attrs && self.name == other.name && self.comma == other.comma
 103    }
 104}
 105#[cfg(any(feature = "derive", feature = "full"))]
 106#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 107impl Eq for crate::BinOp {}
 108#[cfg(any(feature = "derive", feature = "full"))]
 109#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 110impl PartialEq for crate::BinOp {
 111    fn eq(&self, other: &Self) -> bool {
 112        match (self, other) {
 113            (crate::BinOp::Add(_), crate::BinOp::Add(_)) => true,
 114            (crate::BinOp::Sub(_), crate::BinOp::Sub(_)) => true,
 115            (crate::BinOp::Mul(_), crate::BinOp::Mul(_)) => true,
 116            (crate::BinOp::Div(_), crate::BinOp::Div(_)) => true,
 117            (crate::BinOp::Rem(_), crate::BinOp::Rem(_)) => true,
 118            (crate::BinOp::And(_), crate::BinOp::And(_)) => true,
 119            (crate::BinOp::Or(_), crate::BinOp::Or(_)) => true,
 120            (crate::BinOp::BitXor(_), crate::BinOp::BitXor(_)) => true,
 121            (crate::BinOp::BitAnd(_), crate::BinOp::BitAnd(_)) => true,
 122            (crate::BinOp::BitOr(_), crate::BinOp::BitOr(_)) => true,
 123            (crate::BinOp::Shl(_), crate::BinOp::Shl(_)) => true,
 124            (crate::BinOp::Shr(_), crate::BinOp::Shr(_)) => true,
 125            (crate::BinOp::Eq(_), crate::BinOp::Eq(_)) => true,
 126            (crate::BinOp::Lt(_), crate::BinOp::Lt(_)) => true,
 127            (crate::BinOp::Le(_), crate::BinOp::Le(_)) => true,
 128            (crate::BinOp::Ne(_), crate::BinOp::Ne(_)) => true,
 129            (crate::BinOp::Ge(_), crate::BinOp::Ge(_)) => true,
 130            (crate::BinOp::Gt(_), crate::BinOp::Gt(_)) => true,
 131            (crate::BinOp::AddAssign(_), crate::BinOp::AddAssign(_)) => true,
 132            (crate::BinOp::SubAssign(_), crate::BinOp::SubAssign(_)) => true,
 133            (crate::BinOp::MulAssign(_), crate::BinOp::MulAssign(_)) => true,
 134            (crate::BinOp::DivAssign(_), crate::BinOp::DivAssign(_)) => true,
 135            (crate::BinOp::RemAssign(_), crate::BinOp::RemAssign(_)) => true,
 136            (crate::BinOp::BitXorAssign(_), crate::BinOp::BitXorAssign(_)) => true,
 137            (crate::BinOp::BitAndAssign(_), crate::BinOp::BitAndAssign(_)) => true,
 138            (crate::BinOp::BitOrAssign(_), crate::BinOp::BitOrAssign(_)) => true,
 139            (crate::BinOp::ShlAssign(_), crate::BinOp::ShlAssign(_)) => true,
 140            (crate::BinOp::ShrAssign(_), crate::BinOp::ShrAssign(_)) => true,
 141            _ => false,
 142        }
 143    }
 144}
 145#[cfg(feature = "full")]
 146#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 147impl Eq for crate::Block {}
 148#[cfg(feature = "full")]
 149#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 150impl PartialEq for crate::Block {
 151    fn eq(&self, other: &Self) -> bool {
 152        self.stmts == other.stmts
 153    }
 154}
 155#[cfg(any(feature = "derive", feature = "full"))]
 156#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 157impl Eq for crate::BoundLifetimes {}
 158#[cfg(any(feature = "derive", feature = "full"))]
 159#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 160impl PartialEq for crate::BoundLifetimes {
 161    fn eq(&self, other: &Self) -> bool {
 162        self.lifetimes == other.lifetimes
 163    }
 164}
 165#[cfg(feature = "full")]
 166#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 167impl Eq for crate::CapturedParam {}
 168#[cfg(feature = "full")]
 169#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 170impl PartialEq for crate::CapturedParam {
 171    fn eq(&self, other: &Self) -> bool {
 172        match (self, other) {
 173            (
 174                crate::CapturedParam::Lifetime(self0),
 175                crate::CapturedParam::Lifetime(other0),
 176            ) => self0 == other0,
 177            (crate::CapturedParam::Ident(self0), crate::CapturedParam::Ident(other0)) => {
 178                self0 == other0
 179            }
 180            _ => false,
 181        }
 182    }
 183}
 184#[cfg(any(feature = "derive", feature = "full"))]
 185#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 186impl Eq for crate::ConstParam {}
 187#[cfg(any(feature = "derive", feature = "full"))]
 188#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 189impl PartialEq for crate::ConstParam {
 190    fn eq(&self, other: &Self) -> bool {
 191        self.attrs == other.attrs && self.ident == other.ident && self.ty == other.ty
 192            && self.eq_token == other.eq_token && self.default == other.default
 193    }
 194}
 195#[cfg(any(feature = "derive", feature = "full"))]
 196#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 197impl Eq for crate::Constraint {}
 198#[cfg(any(feature = "derive", feature = "full"))]
 199#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 200impl PartialEq for crate::Constraint {
 201    fn eq(&self, other: &Self) -> bool {
 202        self.ident == other.ident && self.generics == other.generics
 203            && self.bounds == other.bounds
 204    }
 205}
 206#[cfg(feature = "derive")]
 207#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 208impl Eq for crate::Data {}
 209#[cfg(feature = "derive")]
 210#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 211impl PartialEq for crate::Data {
 212    fn eq(&self, other: &Self) -> bool {
 213        match (self, other) {
 214            (crate::Data::Struct(self0), crate::Data::Struct(other0)) => self0 == other0,
 215            (crate::Data::Enum(self0), crate::Data::Enum(other0)) => self0 == other0,
 216            (crate::Data::Union(self0), crate::Data::Union(other0)) => self0 == other0,
 217            _ => false,
 218        }
 219    }
 220}
 221#[cfg(feature = "derive")]
 222#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 223impl Eq for crate::DataEnum {}
 224#[cfg(feature = "derive")]
 225#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 226impl PartialEq for crate::DataEnum {
 227    fn eq(&self, other: &Self) -> bool {
 228        self.variants == other.variants
 229    }
 230}
 231#[cfg(feature = "derive")]
 232#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 233impl Eq for crate::DataStruct {}
 234#[cfg(feature = "derive")]
 235#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 236impl PartialEq for crate::DataStruct {
 237    fn eq(&self, other: &Self) -> bool {
 238        self.fields == other.fields && self.semi_token == other.semi_token
 239    }
 240}
 241#[cfg(feature = "derive")]
 242#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 243impl Eq for crate::DataUnion {}
 244#[cfg(feature = "derive")]
 245#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 246impl PartialEq for crate::DataUnion {
 247    fn eq(&self, other: &Self) -> bool {
 248        self.fields == other.fields
 249    }
 250}
 251#[cfg(feature = "derive")]
 252#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 253impl Eq for crate::DeriveInput {}
 254#[cfg(feature = "derive")]
 255#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 256impl PartialEq for crate::DeriveInput {
 257    fn eq(&self, other: &Self) -> bool {
 258        self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
 259            && self.generics == other.generics && self.data == other.data
 260    }
 261}
 262#[cfg(any(feature = "derive", feature = "full"))]
 263#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 264impl Eq for crate::Expr {}
 265#[cfg(any(feature = "derive", feature = "full"))]
 266#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 267impl PartialEq for crate::Expr {
 268    fn eq(&self, other: &Self) -> bool {
 269        match (self, other) {
 270            #[cfg(feature = "full")]
 271            (crate::Expr::Array(self0), crate::Expr::Array(other0)) => self0 == other0,
 272            #[cfg(feature = "full")]
 273            (crate::Expr::Assign(self0), crate::Expr::Assign(other0)) => self0 == other0,
 274            #[cfg(feature = "full")]
 275            (crate::Expr::Async(self0), crate::Expr::Async(other0)) => self0 == other0,
 276            #[cfg(feature = "full")]
 277            (crate::Expr::Await(self0), crate::Expr::Await(other0)) => self0 == other0,
 278            (crate::Expr::Binary(self0), crate::Expr::Binary(other0)) => self0 == other0,
 279            #[cfg(feature = "full")]
 280            (crate::Expr::Block(self0), crate::Expr::Block(other0)) => self0 == other0,
 281            #[cfg(feature = "full")]
 282            (crate::Expr::Break(self0), crate::Expr::Break(other0)) => self0 == other0,
 283            (crate::Expr::Call(self0), crate::Expr::Call(other0)) => self0 == other0,
 284            (crate::Expr::Cast(self0), crate::Expr::Cast(other0)) => self0 == other0,
 285            #[cfg(feature = "full")]
 286            (crate::Expr::Closure(self0), crate::Expr::Closure(other0)) => {
 287                self0 == other0
 288            }
 289            #[cfg(feature = "full")]
 290            (crate::Expr::Const(self0), crate::Expr::Const(other0)) => self0 == other0,
 291            #[cfg(feature = "full")]
 292            (crate::Expr::Continue(self0), crate::Expr::Continue(other0)) => {
 293                self0 == other0
 294            }
 295            (crate::Expr::Field(self0), crate::Expr::Field(other0)) => self0 == other0,
 296            #[cfg(feature = "full")]
 297            (crate::Expr::ForLoop(self0), crate::Expr::ForLoop(other0)) => {
 298                self0 == other0
 299            }
 300            (crate::Expr::Group(self0), crate::Expr::Group(other0)) => self0 == other0,
 301            #[cfg(feature = "full")]
 302            (crate::Expr::If(self0), crate::Expr::If(other0)) => self0 == other0,
 303            (crate::Expr::Index(self0), crate::Expr::Index(other0)) => self0 == other0,
 304            #[cfg(feature = "full")]
 305            (crate::Expr::Infer(self0), crate::Expr::Infer(other0)) => self0 == other0,
 306            #[cfg(feature = "full")]
 307            (crate::Expr::Let(self0), crate::Expr::Let(other0)) => self0 == other0,
 308            (crate::Expr::Lit(self0), crate::Expr::Lit(other0)) => self0 == other0,
 309            #[cfg(feature = "full")]
 310            (crate::Expr::Loop(self0), crate::Expr::Loop(other0)) => self0 == other0,
 311            (crate::Expr::Macro(self0), crate::Expr::Macro(other0)) => self0 == other0,
 312            #[cfg(feature = "full")]
 313            (crate::Expr::Match(self0), crate::Expr::Match(other0)) => self0 == other0,
 314            (crate::Expr::MethodCall(self0), crate::Expr::MethodCall(other0)) => {
 315                self0 == other0
 316            }
 317            (crate::Expr::Paren(self0), crate::Expr::Paren(other0)) => self0 == other0,
 318            (crate::Expr::Path(self0), crate::Expr::Path(other0)) => self0 == other0,
 319            #[cfg(feature = "full")]
 320            (crate::Expr::Range(self0), crate::Expr::Range(other0)) => self0 == other0,
 321            #[cfg(feature = "full")]
 322            (crate::Expr::RawAddr(self0), crate::Expr::RawAddr(other0)) => {
 323                self0 == other0
 324            }
 325            (crate::Expr::Reference(self0), crate::Expr::Reference(other0)) => {
 326                self0 == other0
 327            }
 328            #[cfg(feature = "full")]
 329            (crate::Expr::Repeat(self0), crate::Expr::Repeat(other0)) => self0 == other0,
 330            #[cfg(feature = "full")]
 331            (crate::Expr::Return(self0), crate::Expr::Return(other0)) => self0 == other0,
 332            (crate::Expr::Struct(self0), crate::Expr::Struct(other0)) => self0 == other0,
 333            #[cfg(feature = "full")]
 334            (crate::Expr::Try(self0), crate::Expr::Try(other0)) => self0 == other0,
 335            #[cfg(feature = "full")]
 336            (crate::Expr::TryBlock(self0), crate::Expr::TryBlock(other0)) => {
 337                self0 == other0
 338            }
 339            (crate::Expr::Tuple(self0), crate::Expr::Tuple(other0)) => self0 == other0,
 340            (crate::Expr::Unary(self0), crate::Expr::Unary(other0)) => self0 == other0,
 341            #[cfg(feature = "full")]
 342            (crate::Expr::Unsafe(self0), crate::Expr::Unsafe(other0)) => self0 == other0,
 343            (crate::Expr::Verbatim(self0), crate::Expr::Verbatim(other0)) => {
 344                TokenStreamHelper(self0) == TokenStreamHelper(other0)
 345            }
 346            #[cfg(feature = "full")]
 347            (crate::Expr::While(self0), crate::Expr::While(other0)) => self0 == other0,
 348            #[cfg(feature = "full")]
 349            (crate::Expr::Yield(self0), crate::Expr::Yield(other0)) => self0 == other0,
 350            _ => false,
 351        }
 352    }
 353}
 354#[cfg(feature = "full")]
 355#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 356impl Eq for crate::ExprArray {}
 357#[cfg(feature = "full")]
 358#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 359impl PartialEq for crate::ExprArray {
 360    fn eq(&self, other: &Self) -> bool {
 361        self.attrs == other.attrs && self.elems == other.elems
 362    }
 363}
 364#[cfg(feature = "full")]
 365#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 366impl Eq for crate::ExprAssign {}
 367#[cfg(feature = "full")]
 368#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 369impl PartialEq for crate::ExprAssign {
 370    fn eq(&self, other: &Self) -> bool {
 371        self.attrs == other.attrs && self.left == other.left && self.right == other.right
 372    }
 373}
 374#[cfg(feature = "full")]
 375#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 376impl Eq for crate::ExprAsync {}
 377#[cfg(feature = "full")]
 378#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 379impl PartialEq for crate::ExprAsync {
 380    fn eq(&self, other: &Self) -> bool {
 381        self.attrs == other.attrs && self.capture == other.capture
 382            && self.block == other.block
 383    }
 384}
 385#[cfg(feature = "full")]
 386#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 387impl Eq for crate::ExprAwait {}
 388#[cfg(feature = "full")]
 389#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 390impl PartialEq for crate::ExprAwait {
 391    fn eq(&self, other: &Self) -> bool {
 392        self.attrs == other.attrs && self.base == other.base
 393    }
 394}
 395#[cfg(any(feature = "derive", feature = "full"))]
 396#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 397impl Eq for crate::ExprBinary {}
 398#[cfg(any(feature = "derive", feature = "full"))]
 399#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 400impl PartialEq for crate::ExprBinary {
 401    fn eq(&self, other: &Self) -> bool {
 402        self.attrs == other.attrs && self.left == other.left && self.op == other.op
 403            && self.right == other.right
 404    }
 405}
 406#[cfg(feature = "full")]
 407#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 408impl Eq for crate::ExprBlock {}
 409#[cfg(feature = "full")]
 410#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 411impl PartialEq for crate::ExprBlock {
 412    fn eq(&self, other: &Self) -> bool {
 413        self.attrs == other.attrs && self.label == other.label
 414            && self.block == other.block
 415    }
 416}
 417#[cfg(feature = "full")]
 418#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 419impl Eq for crate::ExprBreak {}
 420#[cfg(feature = "full")]
 421#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 422impl PartialEq for crate::ExprBreak {
 423    fn eq(&self, other: &Self) -> bool {
 424        self.attrs == other.attrs && self.label == other.label && self.expr == other.expr
 425    }
 426}
 427#[cfg(any(feature = "derive", feature = "full"))]
 428#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 429impl Eq for crate::ExprCall {}
 430#[cfg(any(feature = "derive", feature = "full"))]
 431#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 432impl PartialEq for crate::ExprCall {
 433    fn eq(&self, other: &Self) -> bool {
 434        self.attrs == other.attrs && self.func == other.func && self.args == other.args
 435    }
 436}
 437#[cfg(any(feature = "derive", feature = "full"))]
 438#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 439impl Eq for crate::ExprCast {}
 440#[cfg(any(feature = "derive", feature = "full"))]
 441#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 442impl PartialEq for crate::ExprCast {
 443    fn eq(&self, other: &Self) -> bool {
 444        self.attrs == other.attrs && self.expr == other.expr && self.ty == other.ty
 445    }
 446}
 447#[cfg(feature = "full")]
 448#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 449impl Eq for crate::ExprClosure {}
 450#[cfg(feature = "full")]
 451#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 452impl PartialEq for crate::ExprClosure {
 453    fn eq(&self, other: &Self) -> bool {
 454        self.attrs == other.attrs && self.lifetimes == other.lifetimes
 455            && self.constness == other.constness && self.movability == other.movability
 456            && self.asyncness == other.asyncness && self.capture == other.capture
 457            && self.inputs == other.inputs && self.output == other.output
 458            && self.body == other.body
 459    }
 460}
 461#[cfg(feature = "full")]
 462#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 463impl Eq for crate::ExprConst {}
 464#[cfg(feature = "full")]
 465#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 466impl PartialEq for crate::ExprConst {
 467    fn eq(&self, other: &Self) -> bool {
 468        self.attrs == other.attrs && self.block == other.block
 469    }
 470}
 471#[cfg(feature = "full")]
 472#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 473impl Eq for crate::ExprContinue {}
 474#[cfg(feature = "full")]
 475#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 476impl PartialEq for crate::ExprContinue {
 477    fn eq(&self, other: &Self) -> bool {
 478        self.attrs == other.attrs && self.label == other.label
 479    }
 480}
 481#[cfg(any(feature = "derive", feature = "full"))]
 482#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 483impl Eq for crate::ExprField {}
 484#[cfg(any(feature = "derive", feature = "full"))]
 485#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 486impl PartialEq for crate::ExprField {
 487    fn eq(&self, other: &Self) -> bool {
 488        self.attrs == other.attrs && self.base == other.base
 489            && self.member == other.member
 490    }
 491}
 492#[cfg(feature = "full")]
 493#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 494impl Eq for crate::ExprForLoop {}
 495#[cfg(feature = "full")]
 496#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 497impl PartialEq for crate::ExprForLoop {
 498    fn eq(&self, other: &Self) -> bool {
 499        self.attrs == other.attrs && self.label == other.label && self.pat == other.pat
 500            && self.expr == other.expr && self.body == other.body
 501    }
 502}
 503#[cfg(any(feature = "derive", feature = "full"))]
 504#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 505impl Eq for crate::ExprGroup {}
 506#[cfg(any(feature = "derive", feature = "full"))]
 507#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 508impl PartialEq for crate::ExprGroup {
 509    fn eq(&self, other: &Self) -> bool {
 510        self.attrs == other.attrs && self.expr == other.expr
 511    }
 512}
 513#[cfg(feature = "full")]
 514#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 515impl Eq for crate::ExprIf {}
 516#[cfg(feature = "full")]
 517#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 518impl PartialEq for crate::ExprIf {
 519    fn eq(&self, other: &Self) -> bool {
 520        self.attrs == other.attrs && self.cond == other.cond
 521            && self.then_branch == other.then_branch
 522            && self.else_branch == other.else_branch
 523    }
 524}
 525#[cfg(any(feature = "derive", feature = "full"))]
 526#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 527impl Eq for crate::ExprIndex {}
 528#[cfg(any(feature = "derive", feature = "full"))]
 529#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 530impl PartialEq for crate::ExprIndex {
 531    fn eq(&self, other: &Self) -> bool {
 532        self.attrs == other.attrs && self.expr == other.expr && self.index == other.index
 533    }
 534}
 535#[cfg(feature = "full")]
 536#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 537impl Eq for crate::ExprInfer {}
 538#[cfg(feature = "full")]
 539#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 540impl PartialEq for crate::ExprInfer {
 541    fn eq(&self, other: &Self) -> bool {
 542        self.attrs == other.attrs
 543    }
 544}
 545#[cfg(feature = "full")]
 546#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 547impl Eq for crate::ExprLet {}
 548#[cfg(feature = "full")]
 549#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 550impl PartialEq for crate::ExprLet {
 551    fn eq(&self, other: &Self) -> bool {
 552        self.attrs == other.attrs && self.pat == other.pat && self.expr == other.expr
 553    }
 554}
 555#[cfg(any(feature = "derive", feature = "full"))]
 556#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 557impl Eq for crate::ExprLit {}
 558#[cfg(any(feature = "derive", feature = "full"))]
 559#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 560impl PartialEq for crate::ExprLit {
 561    fn eq(&self, other: &Self) -> bool {
 562        self.attrs == other.attrs && self.lit == other.lit
 563    }
 564}
 565#[cfg(feature = "full")]
 566#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 567impl Eq for crate::ExprLoop {}
 568#[cfg(feature = "full")]
 569#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 570impl PartialEq for crate::ExprLoop {
 571    fn eq(&self, other: &Self) -> bool {
 572        self.attrs == other.attrs && self.label == other.label && self.body == other.body
 573    }
 574}
 575#[cfg(any(feature = "derive", feature = "full"))]
 576#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 577impl Eq for crate::ExprMacro {}
 578#[cfg(any(feature = "derive", feature = "full"))]
 579#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 580impl PartialEq for crate::ExprMacro {
 581    fn eq(&self, other: &Self) -> bool {
 582        self.attrs == other.attrs && self.mac == other.mac
 583    }
 584}
 585#[cfg(feature = "full")]
 586#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 587impl Eq for crate::ExprMatch {}
 588#[cfg(feature = "full")]
 589#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 590impl PartialEq for crate::ExprMatch {
 591    fn eq(&self, other: &Self) -> bool {
 592        self.attrs == other.attrs && self.expr == other.expr && self.arms == other.arms
 593    }
 594}
 595#[cfg(any(feature = "derive", feature = "full"))]
 596#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 597impl Eq for crate::ExprMethodCall {}
 598#[cfg(any(feature = "derive", feature = "full"))]
 599#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 600impl PartialEq for crate::ExprMethodCall {
 601    fn eq(&self, other: &Self) -> bool {
 602        self.attrs == other.attrs && self.receiver == other.receiver
 603            && self.method == other.method && self.turbofish == other.turbofish
 604            && self.args == other.args
 605    }
 606}
 607#[cfg(any(feature = "derive", feature = "full"))]
 608#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 609impl Eq for crate::ExprParen {}
 610#[cfg(any(feature = "derive", feature = "full"))]
 611#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 612impl PartialEq for crate::ExprParen {
 613    fn eq(&self, other: &Self) -> bool {
 614        self.attrs == other.attrs && self.expr == other.expr
 615    }
 616}
 617#[cfg(any(feature = "derive", feature = "full"))]
 618#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 619impl Eq for crate::ExprPath {}
 620#[cfg(any(feature = "derive", feature = "full"))]
 621#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 622impl PartialEq for crate::ExprPath {
 623    fn eq(&self, other: &Self) -> bool {
 624        self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
 625    }
 626}
 627#[cfg(feature = "full")]
 628#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 629impl Eq for crate::ExprRange {}
 630#[cfg(feature = "full")]
 631#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 632impl PartialEq for crate::ExprRange {
 633    fn eq(&self, other: &Self) -> bool {
 634        self.attrs == other.attrs && self.start == other.start
 635            && self.limits == other.limits && self.end == other.end
 636    }
 637}
 638#[cfg(feature = "full")]
 639#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 640impl Eq for crate::ExprRawAddr {}
 641#[cfg(feature = "full")]
 642#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 643impl PartialEq for crate::ExprRawAddr {
 644    fn eq(&self, other: &Self) -> bool {
 645        self.attrs == other.attrs && self.mutability == other.mutability
 646            && self.expr == other.expr
 647    }
 648}
 649#[cfg(any(feature = "derive", feature = "full"))]
 650#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 651impl Eq for crate::ExprReference {}
 652#[cfg(any(feature = "derive", feature = "full"))]
 653#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 654impl PartialEq for crate::ExprReference {
 655    fn eq(&self, other: &Self) -> bool {
 656        self.attrs == other.attrs && self.mutability == other.mutability
 657            && self.expr == other.expr
 658    }
 659}
 660#[cfg(feature = "full")]
 661#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 662impl Eq for crate::ExprRepeat {}
 663#[cfg(feature = "full")]
 664#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 665impl PartialEq for crate::ExprRepeat {
 666    fn eq(&self, other: &Self) -> bool {
 667        self.attrs == other.attrs && self.expr == other.expr && self.len == other.len
 668    }
 669}
 670#[cfg(feature = "full")]
 671#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 672impl Eq for crate::ExprReturn {}
 673#[cfg(feature = "full")]
 674#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 675impl PartialEq for crate::ExprReturn {
 676    fn eq(&self, other: &Self) -> bool {
 677        self.attrs == other.attrs && self.expr == other.expr
 678    }
 679}
 680#[cfg(any(feature = "derive", feature = "full"))]
 681#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 682impl Eq for crate::ExprStruct {}
 683#[cfg(any(feature = "derive", feature = "full"))]
 684#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 685impl PartialEq for crate::ExprStruct {
 686    fn eq(&self, other: &Self) -> bool {
 687        self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
 688            && self.fields == other.fields && self.dot2_token == other.dot2_token
 689            && self.rest == other.rest
 690    }
 691}
 692#[cfg(feature = "full")]
 693#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 694impl Eq for crate::ExprTry {}
 695#[cfg(feature = "full")]
 696#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 697impl PartialEq for crate::ExprTry {
 698    fn eq(&self, other: &Self) -> bool {
 699        self.attrs == other.attrs && self.expr == other.expr
 700    }
 701}
 702#[cfg(feature = "full")]
 703#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 704impl Eq for crate::ExprTryBlock {}
 705#[cfg(feature = "full")]
 706#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 707impl PartialEq for crate::ExprTryBlock {
 708    fn eq(&self, other: &Self) -> bool {
 709        self.attrs == other.attrs && self.block == other.block
 710    }
 711}
 712#[cfg(any(feature = "derive", feature = "full"))]
 713#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 714impl Eq for crate::ExprTuple {}
 715#[cfg(any(feature = "derive", feature = "full"))]
 716#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 717impl PartialEq for crate::ExprTuple {
 718    fn eq(&self, other: &Self) -> bool {
 719        self.attrs == other.attrs && self.elems == other.elems
 720    }
 721}
 722#[cfg(any(feature = "derive", feature = "full"))]
 723#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 724impl Eq for crate::ExprUnary {}
 725#[cfg(any(feature = "derive", feature = "full"))]
 726#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 727impl PartialEq for crate::ExprUnary {
 728    fn eq(&self, other: &Self) -> bool {
 729        self.attrs == other.attrs && self.op == other.op && self.expr == other.expr
 730    }
 731}
 732#[cfg(feature = "full")]
 733#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 734impl Eq for crate::ExprUnsafe {}
 735#[cfg(feature = "full")]
 736#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 737impl PartialEq for crate::ExprUnsafe {
 738    fn eq(&self, other: &Self) -> bool {
 739        self.attrs == other.attrs && self.block == other.block
 740    }
 741}
 742#[cfg(feature = "full")]
 743#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 744impl Eq for crate::ExprWhile {}
 745#[cfg(feature = "full")]
 746#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 747impl PartialEq for crate::ExprWhile {
 748    fn eq(&self, other: &Self) -> bool {
 749        self.attrs == other.attrs && self.label == other.label && self.cond == other.cond
 750            && self.body == other.body
 751    }
 752}
 753#[cfg(feature = "full")]
 754#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 755impl Eq for crate::ExprYield {}
 756#[cfg(feature = "full")]
 757#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 758impl PartialEq for crate::ExprYield {
 759    fn eq(&self, other: &Self) -> bool {
 760        self.attrs == other.attrs && self.expr == other.expr
 761    }
 762}
 763#[cfg(any(feature = "derive", feature = "full"))]
 764#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 765impl Eq for crate::Field {}
 766#[cfg(any(feature = "derive", feature = "full"))]
 767#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 768impl PartialEq for crate::Field {
 769    fn eq(&self, other: &Self) -> bool {
 770        self.attrs == other.attrs && self.vis == other.vis
 771            && self.mutability == other.mutability && self.ident == other.ident
 772            && self.colon_token == other.colon_token && self.ty == other.ty
 773    }
 774}
 775#[cfg(any(feature = "derive", feature = "full"))]
 776#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 777impl Eq for crate::FieldMutability {}
 778#[cfg(any(feature = "derive", feature = "full"))]
 779#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 780impl PartialEq for crate::FieldMutability {
 781    fn eq(&self, other: &Self) -> bool {
 782        match (self, other) {
 783            (crate::FieldMutability::None, crate::FieldMutability::None) => true,
 784        }
 785    }
 786}
 787#[cfg(feature = "full")]
 788#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 789impl Eq for crate::FieldPat {}
 790#[cfg(feature = "full")]
 791#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 792impl PartialEq for crate::FieldPat {
 793    fn eq(&self, other: &Self) -> bool {
 794        self.attrs == other.attrs && self.member == other.member
 795            && self.colon_token == other.colon_token && self.pat == other.pat
 796    }
 797}
 798#[cfg(any(feature = "derive", feature = "full"))]
 799#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 800impl Eq for crate::FieldValue {}
 801#[cfg(any(feature = "derive", feature = "full"))]
 802#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 803impl PartialEq for crate::FieldValue {
 804    fn eq(&self, other: &Self) -> bool {
 805        self.attrs == other.attrs && self.member == other.member
 806            && self.colon_token == other.colon_token && self.expr == other.expr
 807    }
 808}
 809#[cfg(any(feature = "derive", feature = "full"))]
 810#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 811impl Eq for crate::Fields {}
 812#[cfg(any(feature = "derive", feature = "full"))]
 813#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 814impl PartialEq for crate::Fields {
 815    fn eq(&self, other: &Self) -> bool {
 816        match (self, other) {
 817            (crate::Fields::Named(self0), crate::Fields::Named(other0)) => {
 818                self0 == other0
 819            }
 820            (crate::Fields::Unnamed(self0), crate::Fields::Unnamed(other0)) => {
 821                self0 == other0
 822            }
 823            (crate::Fields::Unit, crate::Fields::Unit) => true,
 824            _ => false,
 825        }
 826    }
 827}
 828#[cfg(any(feature = "derive", feature = "full"))]
 829#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 830impl Eq for crate::FieldsNamed {}
 831#[cfg(any(feature = "derive", feature = "full"))]
 832#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 833impl PartialEq for crate::FieldsNamed {
 834    fn eq(&self, other: &Self) -> bool {
 835        self.named == other.named
 836    }
 837}
 838#[cfg(any(feature = "derive", feature = "full"))]
 839#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 840impl Eq for crate::FieldsUnnamed {}
 841#[cfg(any(feature = "derive", feature = "full"))]
 842#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 843impl PartialEq for crate::FieldsUnnamed {
 844    fn eq(&self, other: &Self) -> bool {
 845        self.unnamed == other.unnamed
 846    }
 847}
 848#[cfg(feature = "full")]
 849#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 850impl Eq for crate::File {}
 851#[cfg(feature = "full")]
 852#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 853impl PartialEq for crate::File {
 854    fn eq(&self, other: &Self) -> bool {
 855        self.shebang == other.shebang && self.attrs == other.attrs
 856            && self.items == other.items
 857    }
 858}
 859#[cfg(feature = "full")]
 860#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 861impl Eq for crate::FnArg {}
 862#[cfg(feature = "full")]
 863#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 864impl PartialEq for crate::FnArg {
 865    fn eq(&self, other: &Self) -> bool {
 866        match (self, other) {
 867            (crate::FnArg::Receiver(self0), crate::FnArg::Receiver(other0)) => {
 868                self0 == other0
 869            }
 870            (crate::FnArg::Typed(self0), crate::FnArg::Typed(other0)) => self0 == other0,
 871            _ => false,
 872        }
 873    }
 874}
 875#[cfg(feature = "full")]
 876#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 877impl Eq for crate::ForeignItem {}
 878#[cfg(feature = "full")]
 879#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 880impl PartialEq for crate::ForeignItem {
 881    fn eq(&self, other: &Self) -> bool {
 882        match (self, other) {
 883            (crate::ForeignItem::Fn(self0), crate::ForeignItem::Fn(other0)) => {
 884                self0 == other0
 885            }
 886            (crate::ForeignItem::Static(self0), crate::ForeignItem::Static(other0)) => {
 887                self0 == other0
 888            }
 889            (crate::ForeignItem::Type(self0), crate::ForeignItem::Type(other0)) => {
 890                self0 == other0
 891            }
 892            (crate::ForeignItem::Macro(self0), crate::ForeignItem::Macro(other0)) => {
 893                self0 == other0
 894            }
 895            (
 896                crate::ForeignItem::Verbatim(self0),
 897                crate::ForeignItem::Verbatim(other0),
 898            ) => TokenStreamHelper(self0) == TokenStreamHelper(other0),
 899            _ => false,
 900        }
 901    }
 902}
 903#[cfg(feature = "full")]
 904#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 905impl Eq for crate::ForeignItemFn {}
 906#[cfg(feature = "full")]
 907#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 908impl PartialEq for crate::ForeignItemFn {
 909    fn eq(&self, other: &Self) -> bool {
 910        self.attrs == other.attrs && self.vis == other.vis && self.sig == other.sig
 911    }
 912}
 913#[cfg(feature = "full")]
 914#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 915impl Eq for crate::ForeignItemMacro {}
 916#[cfg(feature = "full")]
 917#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 918impl PartialEq for crate::ForeignItemMacro {
 919    fn eq(&self, other: &Self) -> bool {
 920        self.attrs == other.attrs && self.mac == other.mac
 921            && self.semi_token == other.semi_token
 922    }
 923}
 924#[cfg(feature = "full")]
 925#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 926impl Eq for crate::ForeignItemStatic {}
 927#[cfg(feature = "full")]
 928#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 929impl PartialEq for crate::ForeignItemStatic {
 930    fn eq(&self, other: &Self) -> bool {
 931        self.attrs == other.attrs && self.vis == other.vis
 932            && self.mutability == other.mutability && self.ident == other.ident
 933            && self.ty == other.ty
 934    }
 935}
 936#[cfg(feature = "full")]
 937#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 938impl Eq for crate::ForeignItemType {}
 939#[cfg(feature = "full")]
 940#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 941impl PartialEq for crate::ForeignItemType {
 942    fn eq(&self, other: &Self) -> bool {
 943        self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
 944            && self.generics == other.generics
 945    }
 946}
 947#[cfg(any(feature = "derive", feature = "full"))]
 948#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 949impl Eq for crate::GenericArgument {}
 950#[cfg(any(feature = "derive", feature = "full"))]
 951#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 952impl PartialEq for crate::GenericArgument {
 953    fn eq(&self, other: &Self) -> bool {
 954        match (self, other) {
 955            (
 956                crate::GenericArgument::Lifetime(self0),
 957                crate::GenericArgument::Lifetime(other0),
 958            ) => self0 == other0,
 959            (
 960                crate::GenericArgument::Type(self0),
 961                crate::GenericArgument::Type(other0),
 962            ) => self0 == other0,
 963            (
 964                crate::GenericArgument::Const(self0),
 965                crate::GenericArgument::Const(other0),
 966            ) => self0 == other0,
 967            (
 968                crate::GenericArgument::AssocType(self0),
 969                crate::GenericArgument::AssocType(other0),
 970            ) => self0 == other0,
 971            (
 972                crate::GenericArgument::AssocConst(self0),
 973                crate::GenericArgument::AssocConst(other0),
 974            ) => self0 == other0,
 975            (
 976                crate::GenericArgument::Constraint(self0),
 977                crate::GenericArgument::Constraint(other0),
 978            ) => self0 == other0,
 979            _ => false,
 980        }
 981    }
 982}
 983#[cfg(any(feature = "derive", feature = "full"))]
 984#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 985impl Eq for crate::GenericParam {}
 986#[cfg(any(feature = "derive", feature = "full"))]
 987#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
 988impl PartialEq for crate::GenericParam {
 989    fn eq(&self, other: &Self) -> bool {
 990        match (self, other) {
 991            (
 992                crate::GenericParam::Lifetime(self0),
 993                crate::GenericParam::Lifetime(other0),
 994            ) => self0 == other0,
 995            (crate::GenericParam::Type(self0), crate::GenericParam::Type(other0)) => {
 996                self0 == other0
 997            }
 998            (crate::GenericParam::Const(self0), crate::GenericParam::Const(other0)) => {
 999                self0 == other0
1000            }
1001            _ => false,
1002        }
1003    }
1004}
1005#[cfg(any(feature = "derive", feature = "full"))]
1006#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1007impl Eq for crate::Generics {}
1008#[cfg(any(feature = "derive", feature = "full"))]
1009#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1010impl PartialEq for crate::Generics {
1011    fn eq(&self, other: &Self) -> bool {
1012        self.lt_token == other.lt_token && self.params == other.params
1013            && self.gt_token == other.gt_token && self.where_clause == other.where_clause
1014    }
1015}
1016#[cfg(feature = "full")]
1017#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1018impl Eq for crate::ImplItem {}
1019#[cfg(feature = "full")]
1020#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1021impl PartialEq for crate::ImplItem {
1022    fn eq(&self, other: &Self) -> bool {
1023        match (self, other) {
1024            (crate::ImplItem::Const(self0), crate::ImplItem::Const(other0)) => {
1025                self0 == other0
1026            }
1027            (crate::ImplItem::Fn(self0), crate::ImplItem::Fn(other0)) => self0 == other0,
1028            (crate::ImplItem::Type(self0), crate::ImplItem::Type(other0)) => {
1029                self0 == other0
1030            }
1031            (crate::ImplItem::Macro(self0), crate::ImplItem::Macro(other0)) => {
1032                self0 == other0
1033            }
1034            (crate::ImplItem::Verbatim(self0), crate::ImplItem::Verbatim(other0)) => {
1035                TokenStreamHelper(self0) == TokenStreamHelper(other0)
1036            }
1037            _ => false,
1038        }
1039    }
1040}
1041#[cfg(feature = "full")]
1042#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1043impl Eq for crate::ImplItemConst {}
1044#[cfg(feature = "full")]
1045#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1046impl PartialEq for crate::ImplItemConst {
1047    fn eq(&self, other: &Self) -> bool {
1048        self.attrs == other.attrs && self.vis == other.vis
1049            && self.defaultness == other.defaultness && self.ident == other.ident
1050            && self.generics == other.generics && self.ty == other.ty
1051            && self.expr == other.expr
1052    }
1053}
1054#[cfg(feature = "full")]
1055#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1056impl Eq for crate::ImplItemFn {}
1057#[cfg(feature = "full")]
1058#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1059impl PartialEq for crate::ImplItemFn {
1060    fn eq(&self, other: &Self) -> bool {
1061        self.attrs == other.attrs && self.vis == other.vis
1062            && self.defaultness == other.defaultness && self.sig == other.sig
1063            && self.block == other.block
1064    }
1065}
1066#[cfg(feature = "full")]
1067#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1068impl Eq for crate::ImplItemMacro {}
1069#[cfg(feature = "full")]
1070#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1071impl PartialEq for crate::ImplItemMacro {
1072    fn eq(&self, other: &Self) -> bool {
1073        self.attrs == other.attrs && self.mac == other.mac
1074            && self.semi_token == other.semi_token
1075    }
1076}
1077#[cfg(feature = "full")]
1078#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1079impl Eq for crate::ImplItemType {}
1080#[cfg(feature = "full")]
1081#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1082impl PartialEq for crate::ImplItemType {
1083    fn eq(&self, other: &Self) -> bool {
1084        self.attrs == other.attrs && self.vis == other.vis
1085            && self.defaultness == other.defaultness && self.ident == other.ident
1086            && self.generics == other.generics && self.ty == other.ty
1087    }
1088}
1089#[cfg(feature = "full")]
1090#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1091impl Eq for crate::ImplRestriction {}
1092#[cfg(feature = "full")]
1093#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1094impl PartialEq for crate::ImplRestriction {
1095    fn eq(&self, _other: &Self) -> bool {
1096        match *self {}
1097    }
1098}
1099#[cfg(feature = "full")]
1100#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1101impl Eq for crate::Item {}
1102#[cfg(feature = "full")]
1103#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1104impl PartialEq for crate::Item {
1105    fn eq(&self, other: &Self) -> bool {
1106        match (self, other) {
1107            (crate::Item::Const(self0), crate::Item::Const(other0)) => self0 == other0,
1108            (crate::Item::Enum(self0), crate::Item::Enum(other0)) => self0 == other0,
1109            (crate::Item::ExternCrate(self0), crate::Item::ExternCrate(other0)) => {
1110                self0 == other0
1111            }
1112            (crate::Item::Fn(self0), crate::Item::Fn(other0)) => self0 == other0,
1113            (crate::Item::ForeignMod(self0), crate::Item::ForeignMod(other0)) => {
1114                self0 == other0
1115            }
1116            (crate::Item::Impl(self0), crate::Item::Impl(other0)) => self0 == other0,
1117            (crate::Item::Macro(self0), crate::Item::Macro(other0)) => self0 == other0,
1118            (crate::Item::Mod(self0), crate::Item::Mod(other0)) => self0 == other0,
1119            (crate::Item::Static(self0), crate::Item::Static(other0)) => self0 == other0,
1120            (crate::Item::Struct(self0), crate::Item::Struct(other0)) => self0 == other0,
1121            (crate::Item::Trait(self0), crate::Item::Trait(other0)) => self0 == other0,
1122            (crate::Item::TraitAlias(self0), crate::Item::TraitAlias(other0)) => {
1123                self0 == other0
1124            }
1125            (crate::Item::Type(self0), crate::Item::Type(other0)) => self0 == other0,
1126            (crate::Item::Union(self0), crate::Item::Union(other0)) => self0 == other0,
1127            (crate::Item::Use(self0), crate::Item::Use(other0)) => self0 == other0,
1128            (crate::Item::Verbatim(self0), crate::Item::Verbatim(other0)) => {
1129                TokenStreamHelper(self0) == TokenStreamHelper(other0)
1130            }
1131            _ => false,
1132        }
1133    }
1134}
1135#[cfg(feature = "full")]
1136#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1137impl Eq for crate::ItemConst {}
1138#[cfg(feature = "full")]
1139#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1140impl PartialEq for crate::ItemConst {
1141    fn eq(&self, other: &Self) -> bool {
1142        self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1143            && self.generics == other.generics && self.ty == other.ty
1144            && self.expr == other.expr
1145    }
1146}
1147#[cfg(feature = "full")]
1148#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1149impl Eq for crate::ItemEnum {}
1150#[cfg(feature = "full")]
1151#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1152impl PartialEq for crate::ItemEnum {
1153    fn eq(&self, other: &Self) -> bool {
1154        self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1155            && self.generics == other.generics && self.variants == other.variants
1156    }
1157}
1158#[cfg(feature = "full")]
1159#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1160impl Eq for crate::ItemExternCrate {}
1161#[cfg(feature = "full")]
1162#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1163impl PartialEq for crate::ItemExternCrate {
1164    fn eq(&self, other: &Self) -> bool {
1165        self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1166            && self.rename == other.rename
1167    }
1168}
1169#[cfg(feature = "full")]
1170#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1171impl Eq for crate::ItemFn {}
1172#[cfg(feature = "full")]
1173#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1174impl PartialEq for crate::ItemFn {
1175    fn eq(&self, other: &Self) -> bool {
1176        self.attrs == other.attrs && self.vis == other.vis && self.sig == other.sig
1177            && self.block == other.block
1178    }
1179}
1180#[cfg(feature = "full")]
1181#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1182impl Eq for crate::ItemForeignMod {}
1183#[cfg(feature = "full")]
1184#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1185impl PartialEq for crate::ItemForeignMod {
1186    fn eq(&self, other: &Self) -> bool {
1187        self.attrs == other.attrs && self.unsafety == other.unsafety
1188            && self.abi == other.abi && self.items == other.items
1189    }
1190}
1191#[cfg(feature = "full")]
1192#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1193impl Eq for crate::ItemImpl {}
1194#[cfg(feature = "full")]
1195#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1196impl PartialEq for crate::ItemImpl {
1197    fn eq(&self, other: &Self) -> bool {
1198        self.attrs == other.attrs && self.defaultness == other.defaultness
1199            && self.unsafety == other.unsafety && self.generics == other.generics
1200            && self.trait_ == other.trait_ && self.self_ty == other.self_ty
1201            && self.items == other.items
1202    }
1203}
1204#[cfg(feature = "full")]
1205#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1206impl Eq for crate::ItemMacro {}
1207#[cfg(feature = "full")]
1208#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1209impl PartialEq for crate::ItemMacro {
1210    fn eq(&self, other: &Self) -> bool {
1211        self.attrs == other.attrs && self.ident == other.ident && self.mac == other.mac
1212            && self.semi_token == other.semi_token
1213    }
1214}
1215#[cfg(feature = "full")]
1216#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1217impl Eq for crate::ItemMod {}
1218#[cfg(feature = "full")]
1219#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1220impl PartialEq for crate::ItemMod {
1221    fn eq(&self, other: &Self) -> bool {
1222        self.attrs == other.attrs && self.vis == other.vis
1223            && self.unsafety == other.unsafety && self.ident == other.ident
1224            && self.content == other.content && self.semi == other.semi
1225    }
1226}
1227#[cfg(feature = "full")]
1228#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1229impl Eq for crate::ItemStatic {}
1230#[cfg(feature = "full")]
1231#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1232impl PartialEq for crate::ItemStatic {
1233    fn eq(&self, other: &Self) -> bool {
1234        self.attrs == other.attrs && self.vis == other.vis
1235            && self.mutability == other.mutability && self.ident == other.ident
1236            && self.ty == other.ty && self.expr == other.expr
1237    }
1238}
1239#[cfg(feature = "full")]
1240#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1241impl Eq for crate::ItemStruct {}
1242#[cfg(feature = "full")]
1243#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1244impl PartialEq for crate::ItemStruct {
1245    fn eq(&self, other: &Self) -> bool {
1246        self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1247            && self.generics == other.generics && self.fields == other.fields
1248            && self.semi_token == other.semi_token
1249    }
1250}
1251#[cfg(feature = "full")]
1252#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1253impl Eq for crate::ItemTrait {}
1254#[cfg(feature = "full")]
1255#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1256impl PartialEq for crate::ItemTrait {
1257    fn eq(&self, other: &Self) -> bool {
1258        self.attrs == other.attrs && self.vis == other.vis
1259            && self.unsafety == other.unsafety && self.auto_token == other.auto_token
1260            && self.restriction == other.restriction && self.ident == other.ident
1261            && self.generics == other.generics && self.colon_token == other.colon_token
1262            && self.supertraits == other.supertraits && self.items == other.items
1263    }
1264}
1265#[cfg(feature = "full")]
1266#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1267impl Eq for crate::ItemTraitAlias {}
1268#[cfg(feature = "full")]
1269#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1270impl PartialEq for crate::ItemTraitAlias {
1271    fn eq(&self, other: &Self) -> bool {
1272        self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1273            && self.generics == other.generics && self.bounds == other.bounds
1274    }
1275}
1276#[cfg(feature = "full")]
1277#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1278impl Eq for crate::ItemType {}
1279#[cfg(feature = "full")]
1280#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1281impl PartialEq for crate::ItemType {
1282    fn eq(&self, other: &Self) -> bool {
1283        self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1284            && self.generics == other.generics && self.ty == other.ty
1285    }
1286}
1287#[cfg(feature = "full")]
1288#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1289impl Eq for crate::ItemUnion {}
1290#[cfg(feature = "full")]
1291#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1292impl PartialEq for crate::ItemUnion {
1293    fn eq(&self, other: &Self) -> bool {
1294        self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1295            && self.generics == other.generics && self.fields == other.fields
1296    }
1297}
1298#[cfg(feature = "full")]
1299#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1300impl Eq for crate::ItemUse {}
1301#[cfg(feature = "full")]
1302#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1303impl PartialEq for crate::ItemUse {
1304    fn eq(&self, other: &Self) -> bool {
1305        self.attrs == other.attrs && self.vis == other.vis
1306            && self.leading_colon == other.leading_colon && self.tree == other.tree
1307    }
1308}
1309#[cfg(feature = "full")]
1310#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1311impl Eq for crate::Label {}
1312#[cfg(feature = "full")]
1313#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1314impl PartialEq for crate::Label {
1315    fn eq(&self, other: &Self) -> bool {
1316        self.name == other.name
1317    }
1318}
1319#[cfg(any(feature = "derive", feature = "full"))]
1320#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1321impl Eq for crate::LifetimeParam {}
1322#[cfg(any(feature = "derive", feature = "full"))]
1323#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1324impl PartialEq for crate::LifetimeParam {
1325    fn eq(&self, other: &Self) -> bool {
1326        self.attrs == other.attrs && self.lifetime == other.lifetime
1327            && self.colon_token == other.colon_token && self.bounds == other.bounds
1328    }
1329}
1330#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1331impl Eq for crate::Lit {}
1332#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1333impl PartialEq for crate::Lit {
1334    fn eq(&self, other: &Self) -> bool {
1335        match (self, other) {
1336            (crate::Lit::Str(self0), crate::Lit::Str(other0)) => self0 == other0,
1337            (crate::Lit::ByteStr(self0), crate::Lit::ByteStr(other0)) => self0 == other0,
1338            (crate::Lit::CStr(self0), crate::Lit::CStr(other0)) => self0 == other0,
1339            (crate::Lit::Byte(self0), crate::Lit::Byte(other0)) => self0 == other0,
1340            (crate::Lit::Char(self0), crate::Lit::Char(other0)) => self0 == other0,
1341            (crate::Lit::Int(self0), crate::Lit::Int(other0)) => self0 == other0,
1342            (crate::Lit::Float(self0), crate::Lit::Float(other0)) => self0 == other0,
1343            (crate::Lit::Bool(self0), crate::Lit::Bool(other0)) => self0 == other0,
1344            (crate::Lit::Verbatim(self0), crate::Lit::Verbatim(other0)) => {
1345                self0.to_string() == other0.to_string()
1346            }
1347            _ => false,
1348        }
1349    }
1350}
1351#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1352impl Eq for crate::LitBool {}
1353#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1354impl PartialEq for crate::LitBool {
1355    fn eq(&self, other: &Self) -> bool {
1356        self.value == other.value
1357    }
1358}
1359#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1360impl Eq for crate::LitByte {}
1361#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1362impl Eq for crate::LitByteStr {}
1363#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1364impl Eq for crate::LitCStr {}
1365#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1366impl Eq for crate::LitChar {}
1367#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1368impl Eq for crate::LitFloat {}
1369#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1370impl Eq for crate::LitInt {}
1371#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1372impl Eq for crate::LitStr {}
1373#[cfg(feature = "full")]
1374#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1375impl Eq for crate::Local {}
1376#[cfg(feature = "full")]
1377#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1378impl PartialEq for crate::Local {
1379    fn eq(&self, other: &Self) -> bool {
1380        self.attrs == other.attrs && self.pat == other.pat && self.init == other.init
1381    }
1382}
1383#[cfg(feature = "full")]
1384#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1385impl Eq for crate::LocalInit {}
1386#[cfg(feature = "full")]
1387#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1388impl PartialEq for crate::LocalInit {
1389    fn eq(&self, other: &Self) -> bool {
1390        self.expr == other.expr && self.diverge == other.diverge
1391    }
1392}
1393#[cfg(any(feature = "derive", feature = "full"))]
1394#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1395impl Eq for crate::Macro {}
1396#[cfg(any(feature = "derive", feature = "full"))]
1397#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1398impl PartialEq for crate::Macro {
1399    fn eq(&self, other: &Self) -> bool {
1400        self.path == other.path && self.delimiter == other.delimiter
1401            && TokenStreamHelper(&self.tokens) == TokenStreamHelper(&other.tokens)
1402    }
1403}
1404#[cfg(any(feature = "derive", feature = "full"))]
1405#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1406impl Eq for crate::MacroDelimiter {}
1407#[cfg(any(feature = "derive", feature = "full"))]
1408#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1409impl PartialEq for crate::MacroDelimiter {
1410    fn eq(&self, other: &Self) -> bool {
1411        match (self, other) {
1412            (crate::MacroDelimiter::Paren(_), crate::MacroDelimiter::Paren(_)) => true,
1413            (crate::MacroDelimiter::Brace(_), crate::MacroDelimiter::Brace(_)) => true,
1414            (crate::MacroDelimiter::Bracket(_), crate::MacroDelimiter::Bracket(_)) => {
1415                true
1416            }
1417            _ => false,
1418        }
1419    }
1420}
1421#[cfg(any(feature = "derive", feature = "full"))]
1422#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1423impl Eq for crate::Meta {}
1424#[cfg(any(feature = "derive", feature = "full"))]
1425#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1426impl PartialEq for crate::Meta {
1427    fn eq(&self, other: &Self) -> bool {
1428        match (self, other) {
1429            (crate::Meta::Path(self0), crate::Meta::Path(other0)) => self0 == other0,
1430            (crate::Meta::List(self0), crate::Meta::List(other0)) => self0 == other0,
1431            (crate::Meta::NameValue(self0), crate::Meta::NameValue(other0)) => {
1432                self0 == other0
1433            }
1434            _ => false,
1435        }
1436    }
1437}
1438#[cfg(any(feature = "derive", feature = "full"))]
1439#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1440impl Eq for crate::MetaList {}
1441#[cfg(any(feature = "derive", feature = "full"))]
1442#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1443impl PartialEq for crate::MetaList {
1444    fn eq(&self, other: &Self) -> bool {
1445        self.path == other.path && self.delimiter == other.delimiter
1446            && TokenStreamHelper(&self.tokens) == TokenStreamHelper(&other.tokens)
1447    }
1448}
1449#[cfg(any(feature = "derive", feature = "full"))]
1450#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1451impl Eq for crate::MetaNameValue {}
1452#[cfg(any(feature = "derive", feature = "full"))]
1453#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1454impl PartialEq for crate::MetaNameValue {
1455    fn eq(&self, other: &Self) -> bool {
1456        self.path == other.path && self.value == other.value
1457    }
1458}
1459#[cfg(any(feature = "derive", feature = "full"))]
1460#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1461impl Eq for crate::ParenthesizedGenericArguments {}
1462#[cfg(any(feature = "derive", feature = "full"))]
1463#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1464impl PartialEq for crate::ParenthesizedGenericArguments {
1465    fn eq(&self, other: &Self) -> bool {
1466        self.inputs == other.inputs && self.output == other.output
1467    }
1468}
1469#[cfg(feature = "full")]
1470#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1471impl Eq for crate::Pat {}
1472#[cfg(feature = "full")]
1473#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1474impl PartialEq for crate::Pat {
1475    fn eq(&self, other: &Self) -> bool {
1476        match (self, other) {
1477            (crate::Pat::Const(self0), crate::Pat::Const(other0)) => self0 == other0,
1478            (crate::Pat::Ident(self0), crate::Pat::Ident(other0)) => self0 == other0,
1479            (crate::Pat::Lit(self0), crate::Pat::Lit(other0)) => self0 == other0,
1480            (crate::Pat::Macro(self0), crate::Pat::Macro(other0)) => self0 == other0,
1481            (crate::Pat::Or(self0), crate::Pat::Or(other0)) => self0 == other0,
1482            (crate::Pat::Paren(self0), crate::Pat::Paren(other0)) => self0 == other0,
1483            (crate::Pat::Path(self0), crate::Pat::Path(other0)) => self0 == other0,
1484            (crate::Pat::Range(self0), crate::Pat::Range(other0)) => self0 == other0,
1485            (crate::Pat::Reference(self0), crate::Pat::Reference(other0)) => {
1486                self0 == other0
1487            }
1488            (crate::Pat::Rest(self0), crate::Pat::Rest(other0)) => self0 == other0,
1489            (crate::Pat::Slice(self0), crate::Pat::Slice(other0)) => self0 == other0,
1490            (crate::Pat::Struct(self0), crate::Pat::Struct(other0)) => self0 == other0,
1491            (crate::Pat::Tuple(self0), crate::Pat::Tuple(other0)) => self0 == other0,
1492            (crate::Pat::TupleStruct(self0), crate::Pat::TupleStruct(other0)) => {
1493                self0 == other0
1494            }
1495            (crate::Pat::Type(self0), crate::Pat::Type(other0)) => self0 == other0,
1496            (crate::Pat::Verbatim(self0), crate::Pat::Verbatim(other0)) => {
1497                TokenStreamHelper(self0) == TokenStreamHelper(other0)
1498            }
1499            (crate::Pat::Wild(self0), crate::Pat::Wild(other0)) => self0 == other0,
1500            _ => false,
1501        }
1502    }
1503}
1504#[cfg(feature = "full")]
1505#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1506impl Eq for crate::PatIdent {}
1507#[cfg(feature = "full")]
1508#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1509impl PartialEq for crate::PatIdent {
1510    fn eq(&self, other: &Self) -> bool {
1511        self.attrs == other.attrs && self.by_ref == other.by_ref
1512            && self.mutability == other.mutability && self.ident == other.ident
1513            && self.subpat == other.subpat
1514    }
1515}
1516#[cfg(feature = "full")]
1517#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1518impl Eq for crate::PatOr {}
1519#[cfg(feature = "full")]
1520#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1521impl PartialEq for crate::PatOr {
1522    fn eq(&self, other: &Self) -> bool {
1523        self.attrs == other.attrs && self.leading_vert == other.leading_vert
1524            && self.cases == other.cases
1525    }
1526}
1527#[cfg(feature = "full")]
1528#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1529impl Eq for crate::PatParen {}
1530#[cfg(feature = "full")]
1531#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1532impl PartialEq for crate::PatParen {
1533    fn eq(&self, other: &Self) -> bool {
1534        self.attrs == other.attrs && self.pat == other.pat
1535    }
1536}
1537#[cfg(feature = "full")]
1538#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1539impl Eq for crate::PatReference {}
1540#[cfg(feature = "full")]
1541#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1542impl PartialEq for crate::PatReference {
1543    fn eq(&self, other: &Self) -> bool {
1544        self.attrs == other.attrs && self.mutability == other.mutability
1545            && self.pat == other.pat
1546    }
1547}
1548#[cfg(feature = "full")]
1549#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1550impl Eq for crate::PatRest {}
1551#[cfg(feature = "full")]
1552#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1553impl PartialEq for crate::PatRest {
1554    fn eq(&self, other: &Self) -> bool {
1555        self.attrs == other.attrs
1556    }
1557}
1558#[cfg(feature = "full")]
1559#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1560impl Eq for crate::PatSlice {}
1561#[cfg(feature = "full")]
1562#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1563impl PartialEq for crate::PatSlice {
1564    fn eq(&self, other: &Self) -> bool {
1565        self.attrs == other.attrs && self.elems == other.elems
1566    }
1567}
1568#[cfg(feature = "full")]
1569#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1570impl Eq for crate::PatStruct {}
1571#[cfg(feature = "full")]
1572#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1573impl PartialEq for crate::PatStruct {
1574    fn eq(&self, other: &Self) -> bool {
1575        self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
1576            && self.fields == other.fields && self.rest == other.rest
1577    }
1578}
1579#[cfg(feature = "full")]
1580#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1581impl Eq for crate::PatTuple {}
1582#[cfg(feature = "full")]
1583#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1584impl PartialEq for crate::PatTuple {
1585    fn eq(&self, other: &Self) -> bool {
1586        self.attrs == other.attrs && self.elems == other.elems
1587    }
1588}
1589#[cfg(feature = "full")]
1590#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1591impl Eq for crate::PatTupleStruct {}
1592#[cfg(feature = "full")]
1593#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1594impl PartialEq for crate::PatTupleStruct {
1595    fn eq(&self, other: &Self) -> bool {
1596        self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
1597            && self.elems == other.elems
1598    }
1599}
1600#[cfg(feature = "full")]
1601#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1602impl Eq for crate::PatType {}
1603#[cfg(feature = "full")]
1604#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1605impl PartialEq for crate::PatType {
1606    fn eq(&self, other: &Self) -> bool {
1607        self.attrs == other.attrs && self.pat == other.pat && self.ty == other.ty
1608    }
1609}
1610#[cfg(feature = "full")]
1611#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1612impl Eq for crate::PatWild {}
1613#[cfg(feature = "full")]
1614#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1615impl PartialEq for crate::PatWild {
1616    fn eq(&self, other: &Self) -> bool {
1617        self.attrs == other.attrs
1618    }
1619}
1620#[cfg(any(feature = "derive", feature = "full"))]
1621#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1622impl Eq for crate::Path {}
1623#[cfg(any(feature = "derive", feature = "full"))]
1624#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1625impl PartialEq for crate::Path {
1626    fn eq(&self, other: &Self) -> bool {
1627        self.leading_colon == other.leading_colon && self.segments == other.segments
1628    }
1629}
1630#[cfg(any(feature = "derive", feature = "full"))]
1631#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1632impl Eq for crate::PathArguments {}
1633#[cfg(any(feature = "derive", feature = "full"))]
1634#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1635impl PartialEq for crate::PathArguments {
1636    fn eq(&self, other: &Self) -> bool {
1637        match (self, other) {
1638            (crate::PathArguments::None, crate::PathArguments::None) => true,
1639            (
1640                crate::PathArguments::AngleBracketed(self0),
1641                crate::PathArguments::AngleBracketed(other0),
1642            ) => self0 == other0,
1643            (
1644                crate::PathArguments::Parenthesized(self0),
1645                crate::PathArguments::Parenthesized(other0),
1646            ) => self0 == other0,
1647            _ => false,
1648        }
1649    }
1650}
1651#[cfg(any(feature = "derive", feature = "full"))]
1652#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1653impl Eq for crate::PathSegment {}
1654#[cfg(any(feature = "derive", feature = "full"))]
1655#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1656impl PartialEq for crate::PathSegment {
1657    fn eq(&self, other: &Self) -> bool {
1658        self.ident == other.ident && self.arguments == other.arguments
1659    }
1660}
1661#[cfg(feature = "full")]
1662#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1663impl Eq for crate::PointerMutability {}
1664#[cfg(feature = "full")]
1665#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1666impl PartialEq for crate::PointerMutability {
1667    fn eq(&self, other: &Self) -> bool {
1668        match (self, other) {
1669            (crate::PointerMutability::Const(_), crate::PointerMutability::Const(_)) => {
1670                true
1671            }
1672            (crate::PointerMutability::Mut(_), crate::PointerMutability::Mut(_)) => true,
1673            _ => false,
1674        }
1675    }
1676}
1677#[cfg(feature = "full")]
1678#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1679impl Eq for crate::PreciseCapture {}
1680#[cfg(feature = "full")]
1681#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1682impl PartialEq for crate::PreciseCapture {
1683    fn eq(&self, other: &Self) -> bool {
1684        self.params == other.params
1685    }
1686}
1687#[cfg(any(feature = "derive", feature = "full"))]
1688#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1689impl Eq for crate::PredicateLifetime {}
1690#[cfg(any(feature = "derive", feature = "full"))]
1691#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1692impl PartialEq for crate::PredicateLifetime {
1693    fn eq(&self, other: &Self) -> bool {
1694        self.lifetime == other.lifetime && self.bounds == other.bounds
1695    }
1696}
1697#[cfg(any(feature = "derive", feature = "full"))]
1698#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1699impl Eq for crate::PredicateType {}
1700#[cfg(any(feature = "derive", feature = "full"))]
1701#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1702impl PartialEq for crate::PredicateType {
1703    fn eq(&self, other: &Self) -> bool {
1704        self.lifetimes == other.lifetimes && self.bounded_ty == other.bounded_ty
1705            && self.bounds == other.bounds
1706    }
1707}
1708#[cfg(any(feature = "derive", feature = "full"))]
1709#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1710impl Eq for crate::QSelf {}
1711#[cfg(any(feature = "derive", feature = "full"))]
1712#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1713impl PartialEq for crate::QSelf {
1714    fn eq(&self, other: &Self) -> bool {
1715        self.ty == other.ty && self.position == other.position
1716            && self.as_token == other.as_token
1717    }
1718}
1719#[cfg(feature = "full")]
1720#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1721impl Eq for crate::RangeLimits {}
1722#[cfg(feature = "full")]
1723#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1724impl PartialEq for crate::RangeLimits {
1725    fn eq(&self, other: &Self) -> bool {
1726        match (self, other) {
1727            (crate::RangeLimits::HalfOpen(_), crate::RangeLimits::HalfOpen(_)) => true,
1728            (crate::RangeLimits::Closed(_), crate::RangeLimits::Closed(_)) => true,
1729            _ => false,
1730        }
1731    }
1732}
1733#[cfg(feature = "full")]
1734#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1735impl Eq for crate::Receiver {}
1736#[cfg(feature = "full")]
1737#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1738impl PartialEq for crate::Receiver {
1739    fn eq(&self, other: &Self) -> bool {
1740        self.attrs == other.attrs && self.reference == other.reference
1741            && self.mutability == other.mutability
1742            && self.colon_token == other.colon_token && self.ty == other.ty
1743    }
1744}
1745#[cfg(any(feature = "derive", feature = "full"))]
1746#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1747impl Eq for crate::ReturnType {}
1748#[cfg(any(feature = "derive", feature = "full"))]
1749#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1750impl PartialEq for crate::ReturnType {
1751    fn eq(&self, other: &Self) -> bool {
1752        match (self, other) {
1753            (crate::ReturnType::Default, crate::ReturnType::Default) => true,
1754            (crate::ReturnType::Type(_, self1), crate::ReturnType::Type(_, other1)) => {
1755                self1 == other1
1756            }
1757            _ => false,
1758        }
1759    }
1760}
1761#[cfg(feature = "full")]
1762#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1763impl Eq for crate::Signature {}
1764#[cfg(feature = "full")]
1765#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1766impl PartialEq for crate::Signature {
1767    fn eq(&self, other: &Self) -> bool {
1768        self.constness == other.constness && self.asyncness == other.asyncness
1769            && self.unsafety == other.unsafety && self.abi == other.abi
1770            && self.ident == other.ident && self.generics == other.generics
1771            && self.inputs == other.inputs && self.variadic == other.variadic
1772            && self.output == other.output
1773    }
1774}
1775#[cfg(feature = "full")]
1776#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1777impl Eq for crate::StaticMutability {}
1778#[cfg(feature = "full")]
1779#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1780impl PartialEq for crate::StaticMutability {
1781    fn eq(&self, other: &Self) -> bool {
1782        match (self, other) {
1783            (crate::StaticMutability::Mut(_), crate::StaticMutability::Mut(_)) => true,
1784            (crate::StaticMutability::None, crate::StaticMutability::None) => true,
1785            _ => false,
1786        }
1787    }
1788}
1789#[cfg(feature = "full")]
1790#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1791impl Eq for crate::Stmt {}
1792#[cfg(feature = "full")]
1793#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1794impl PartialEq for crate::Stmt {
1795    fn eq(&self, other: &Self) -> bool {
1796        match (self, other) {
1797            (crate::Stmt::Local(self0), crate::Stmt::Local(other0)) => self0 == other0,
1798            (crate::Stmt::Item(self0), crate::Stmt::Item(other0)) => self0 == other0,
1799            (crate::Stmt::Expr(self0, self1), crate::Stmt::Expr(other0, other1)) => {
1800                self0 == other0 && self1 == other1
1801            }
1802            (crate::Stmt::Macro(self0), crate::Stmt::Macro(other0)) => self0 == other0,
1803            _ => false,
1804        }
1805    }
1806}
1807#[cfg(feature = "full")]
1808#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1809impl Eq for crate::StmtMacro {}
1810#[cfg(feature = "full")]
1811#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1812impl PartialEq for crate::StmtMacro {
1813    fn eq(&self, other: &Self) -> bool {
1814        self.attrs == other.attrs && self.mac == other.mac
1815            && self.semi_token == other.semi_token
1816    }
1817}
1818#[cfg(any(feature = "derive", feature = "full"))]
1819#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1820impl Eq for crate::TraitBound {}
1821#[cfg(any(feature = "derive", feature = "full"))]
1822#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1823impl PartialEq for crate::TraitBound {
1824    fn eq(&self, other: &Self) -> bool {
1825        self.paren_token == other.paren_token && self.modifier == other.modifier
1826            && self.lifetimes == other.lifetimes && self.path == other.path
1827    }
1828}
1829#[cfg(any(feature = "derive", feature = "full"))]
1830#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1831impl Eq for crate::TraitBoundModifier {}
1832#[cfg(any(feature = "derive", feature = "full"))]
1833#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1834impl PartialEq for crate::TraitBoundModifier {
1835    fn eq(&self, other: &Self) -> bool {
1836        match (self, other) {
1837            (crate::TraitBoundModifier::None, crate::TraitBoundModifier::None) => true,
1838            (
1839                crate::TraitBoundModifier::Maybe(_),
1840                crate::TraitBoundModifier::Maybe(_),
1841            ) => true,
1842            _ => false,
1843        }
1844    }
1845}
1846#[cfg(feature = "full")]
1847#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1848impl Eq for crate::TraitItem {}
1849#[cfg(feature = "full")]
1850#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1851impl PartialEq for crate::TraitItem {
1852    fn eq(&self, other: &Self) -> bool {
1853        match (self, other) {
1854            (crate::TraitItem::Const(self0), crate::TraitItem::Const(other0)) => {
1855                self0 == other0
1856            }
1857            (crate::TraitItem::Fn(self0), crate::TraitItem::Fn(other0)) => {
1858                self0 == other0
1859            }
1860            (crate::TraitItem::Type(self0), crate::TraitItem::Type(other0)) => {
1861                self0 == other0
1862            }
1863            (crate::TraitItem::Macro(self0), crate::TraitItem::Macro(other0)) => {
1864                self0 == other0
1865            }
1866            (crate::TraitItem::Verbatim(self0), crate::TraitItem::Verbatim(other0)) => {
1867                TokenStreamHelper(self0) == TokenStreamHelper(other0)
1868            }
1869            _ => false,
1870        }
1871    }
1872}
1873#[cfg(feature = "full")]
1874#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1875impl Eq for crate::TraitItemConst {}
1876#[cfg(feature = "full")]
1877#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1878impl PartialEq for crate::TraitItemConst {
1879    fn eq(&self, other: &Self) -> bool {
1880        self.attrs == other.attrs && self.ident == other.ident
1881            && self.generics == other.generics && self.ty == other.ty
1882            && self.default == other.default
1883    }
1884}
1885#[cfg(feature = "full")]
1886#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1887impl Eq for crate::TraitItemFn {}
1888#[cfg(feature = "full")]
1889#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1890impl PartialEq for crate::TraitItemFn {
1891    fn eq(&self, other: &Self) -> bool {
1892        self.attrs == other.attrs && self.sig == other.sig
1893            && self.default == other.default && self.semi_token == other.semi_token
1894    }
1895}
1896#[cfg(feature = "full")]
1897#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1898impl Eq for crate::TraitItemMacro {}
1899#[cfg(feature = "full")]
1900#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1901impl PartialEq for crate::TraitItemMacro {
1902    fn eq(&self, other: &Self) -> bool {
1903        self.attrs == other.attrs && self.mac == other.mac
1904            && self.semi_token == other.semi_token
1905    }
1906}
1907#[cfg(feature = "full")]
1908#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1909impl Eq for crate::TraitItemType {}
1910#[cfg(feature = "full")]
1911#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1912impl PartialEq for crate::TraitItemType {
1913    fn eq(&self, other: &Self) -> bool {
1914        self.attrs == other.attrs && self.ident == other.ident
1915            && self.generics == other.generics && self.colon_token == other.colon_token
1916            && self.bounds == other.bounds && self.default == other.default
1917    }
1918}
1919#[cfg(any(feature = "derive", feature = "full"))]
1920#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1921impl Eq for crate::Type {}
1922#[cfg(any(feature = "derive", feature = "full"))]
1923#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1924impl PartialEq for crate::Type {
1925    fn eq(&self, other: &Self) -> bool {
1926        match (self, other) {
1927            (crate::Type::Array(self0), crate::Type::Array(other0)) => self0 == other0,
1928            (crate::Type::BareFn(self0), crate::Type::BareFn(other0)) => self0 == other0,
1929            (crate::Type::Group(self0), crate::Type::Group(other0)) => self0 == other0,
1930            (crate::Type::ImplTrait(self0), crate::Type::ImplTrait(other0)) => {
1931                self0 == other0
1932            }
1933            (crate::Type::Infer(self0), crate::Type::Infer(other0)) => self0 == other0,
1934            (crate::Type::Macro(self0), crate::Type::Macro(other0)) => self0 == other0,
1935            (crate::Type::Never(self0), crate::Type::Never(other0)) => self0 == other0,
1936            (crate::Type::Paren(self0), crate::Type::Paren(other0)) => self0 == other0,
1937            (crate::Type::Path(self0), crate::Type::Path(other0)) => self0 == other0,
1938            (crate::Type::Ptr(self0), crate::Type::Ptr(other0)) => self0 == other0,
1939            (crate::Type::Reference(self0), crate::Type::Reference(other0)) => {
1940                self0 == other0
1941            }
1942            (crate::Type::Slice(self0), crate::Type::Slice(other0)) => self0 == other0,
1943            (crate::Type::TraitObject(self0), crate::Type::TraitObject(other0)) => {
1944                self0 == other0
1945            }
1946            (crate::Type::Tuple(self0), crate::Type::Tuple(other0)) => self0 == other0,
1947            (crate::Type::Verbatim(self0), crate::Type::Verbatim(other0)) => {
1948                TokenStreamHelper(self0) == TokenStreamHelper(other0)
1949            }
1950            _ => false,
1951        }
1952    }
1953}
1954#[cfg(any(feature = "derive", feature = "full"))]
1955#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1956impl Eq for crate::TypeArray {}
1957#[cfg(any(feature = "derive", feature = "full"))]
1958#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1959impl PartialEq for crate::TypeArray {
1960    fn eq(&self, other: &Self) -> bool {
1961        self.elem == other.elem && self.len == other.len
1962    }
1963}
1964#[cfg(any(feature = "derive", feature = "full"))]
1965#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1966impl Eq for crate::TypeBareFn {}
1967#[cfg(any(feature = "derive", feature = "full"))]
1968#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1969impl PartialEq for crate::TypeBareFn {
1970    fn eq(&self, other: &Self) -> bool {
1971        self.lifetimes == other.lifetimes && self.unsafety == other.unsafety
1972            && self.abi == other.abi && self.inputs == other.inputs
1973            && self.variadic == other.variadic && self.output == other.output
1974    }
1975}
1976#[cfg(any(feature = "derive", feature = "full"))]
1977#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1978impl Eq for crate::TypeGroup {}
1979#[cfg(any(feature = "derive", feature = "full"))]
1980#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1981impl PartialEq for crate::TypeGroup {
1982    fn eq(&self, other: &Self) -> bool {
1983        self.elem == other.elem
1984    }
1985}
1986#[cfg(any(feature = "derive", feature = "full"))]
1987#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1988impl Eq for crate::TypeImplTrait {}
1989#[cfg(any(feature = "derive", feature = "full"))]
1990#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1991impl PartialEq for crate::TypeImplTrait {
1992    fn eq(&self, other: &Self) -> bool {
1993        self.bounds == other.bounds
1994    }
1995}
1996#[cfg(any(feature = "derive", feature = "full"))]
1997#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1998impl Eq for crate::TypeInfer {}
1999#[cfg(any(feature = "derive", feature = "full"))]
2000#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2001impl PartialEq for crate::TypeInfer {
2002    fn eq(&self, _other: &Self) -> bool {
2003        true
2004    }
2005}
2006#[cfg(any(feature = "derive", feature = "full"))]
2007#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2008impl Eq for crate::TypeMacro {}
2009#[cfg(any(feature = "derive", feature = "full"))]
2010#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2011impl PartialEq for crate::TypeMacro {
2012    fn eq(&self, other: &Self) -> bool {
2013        self.mac == other.mac
2014    }
2015}
2016#[cfg(any(feature = "derive", feature = "full"))]
2017#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2018impl Eq for crate::TypeNever {}
2019#[cfg(any(feature = "derive", feature = "full"))]
2020#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2021impl PartialEq for crate::TypeNever {
2022    fn eq(&self, _other: &Self) -> bool {
2023        true
2024    }
2025}
2026#[cfg(any(feature = "derive", feature = "full"))]
2027#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2028impl Eq for crate::TypeParam {}
2029#[cfg(any(feature = "derive", feature = "full"))]
2030#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2031impl PartialEq for crate::TypeParam {
2032    fn eq(&self, other: &Self) -> bool {
2033        self.attrs == other.attrs && self.ident == other.ident
2034            && self.colon_token == other.colon_token && self.bounds == other.bounds
2035            && self.eq_token == other.eq_token && self.default == other.default
2036    }
2037}
2038#[cfg(any(feature = "derive", feature = "full"))]
2039#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2040impl Eq for crate::TypeParamBound {}
2041#[cfg(any(feature = "derive", feature = "full"))]
2042#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2043impl PartialEq for crate::TypeParamBound {
2044    fn eq(&self, other: &Self) -> bool {
2045        match (self, other) {
2046            (
2047                crate::TypeParamBound::Trait(self0),
2048                crate::TypeParamBound::Trait(other0),
2049            ) => self0 == other0,
2050            (
2051                crate::TypeParamBound::Lifetime(self0),
2052                crate::TypeParamBound::Lifetime(other0),
2053            ) => self0 == other0,
2054            #[cfg(feature = "full")]
2055            (
2056                crate::TypeParamBound::PreciseCapture(self0),
2057                crate::TypeParamBound::PreciseCapture(other0),
2058            ) => self0 == other0,
2059            (
2060                crate::TypeParamBound::Verbatim(self0),
2061                crate::TypeParamBound::Verbatim(other0),
2062            ) => TokenStreamHelper(self0) == TokenStreamHelper(other0),
2063            _ => false,
2064        }
2065    }
2066}
2067#[cfg(any(feature = "derive", feature = "full"))]
2068#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2069impl Eq for crate::TypeParen {}
2070#[cfg(any(feature = "derive", feature = "full"))]
2071#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2072impl PartialEq for crate::TypeParen {
2073    fn eq(&self, other: &Self) -> bool {
2074        self.elem == other.elem
2075    }
2076}
2077#[cfg(any(feature = "derive", feature = "full"))]
2078#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2079impl Eq for crate::TypePath {}
2080#[cfg(any(feature = "derive", feature = "full"))]
2081#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2082impl PartialEq for crate::TypePath {
2083    fn eq(&self, other: &Self) -> bool {
2084        self.qself == other.qself && self.path == other.path
2085    }
2086}
2087#[cfg(any(feature = "derive", feature = "full"))]
2088#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2089impl Eq for crate::TypePtr {}
2090#[cfg(any(feature = "derive", feature = "full"))]
2091#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2092impl PartialEq for crate::TypePtr {
2093    fn eq(&self, other: &Self) -> bool {
2094        self.const_token == other.const_token && self.mutability == other.mutability
2095            && self.elem == other.elem
2096    }
2097}
2098#[cfg(any(feature = "derive", feature = "full"))]
2099#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2100impl Eq for crate::TypeReference {}
2101#[cfg(any(feature = "derive", feature = "full"))]
2102#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2103impl PartialEq for crate::TypeReference {
2104    fn eq(&self, other: &Self) -> bool {
2105        self.lifetime == other.lifetime && self.mutability == other.mutability
2106            && self.elem == other.elem
2107    }
2108}
2109#[cfg(any(feature = "derive", feature = "full"))]
2110#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2111impl Eq for crate::TypeSlice {}
2112#[cfg(any(feature = "derive", feature = "full"))]
2113#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2114impl PartialEq for crate::TypeSlice {
2115    fn eq(&self, other: &Self) -> bool {
2116        self.elem == other.elem
2117    }
2118}
2119#[cfg(any(feature = "derive", feature = "full"))]
2120#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2121impl Eq for crate::TypeTraitObject {}
2122#[cfg(any(feature = "derive", feature = "full"))]
2123#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2124impl PartialEq for crate::TypeTraitObject {
2125    fn eq(&self, other: &Self) -> bool {
2126        self.dyn_token == other.dyn_token && self.bounds == other.bounds
2127    }
2128}
2129#[cfg(any(feature = "derive", feature = "full"))]
2130#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2131impl Eq for crate::TypeTuple {}
2132#[cfg(any(feature = "derive", feature = "full"))]
2133#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2134impl PartialEq for crate::TypeTuple {
2135    fn eq(&self, other: &Self) -> bool {
2136        self.elems == other.elems
2137    }
2138}
2139#[cfg(any(feature = "derive", feature = "full"))]
2140#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2141impl Eq for crate::UnOp {}
2142#[cfg(any(feature = "derive", feature = "full"))]
2143#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2144impl PartialEq for crate::UnOp {
2145    fn eq(&self, other: &Self) -> bool {
2146        match (self, other) {
2147            (crate::UnOp::Deref(_), crate::UnOp::Deref(_)) => true,
2148            (crate::UnOp::Not(_), crate::UnOp::Not(_)) => true,
2149            (crate::UnOp::Neg(_), crate::UnOp::Neg(_)) => true,
2150            _ => false,
2151        }
2152    }
2153}
2154#[cfg(feature = "full")]
2155#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2156impl Eq for crate::UseGlob {}
2157#[cfg(feature = "full")]
2158#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2159impl PartialEq for crate::UseGlob {
2160    fn eq(&self, _other: &Self) -> bool {
2161        true
2162    }
2163}
2164#[cfg(feature = "full")]
2165#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2166impl Eq for crate::UseGroup {}
2167#[cfg(feature = "full")]
2168#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2169impl PartialEq for crate::UseGroup {
2170    fn eq(&self, other: &Self) -> bool {
2171        self.items == other.items
2172    }
2173}
2174#[cfg(feature = "full")]
2175#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2176impl Eq for crate::UseName {}
2177#[cfg(feature = "full")]
2178#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2179impl PartialEq for crate::UseName {
2180    fn eq(&self, other: &Self) -> bool {
2181        self.ident == other.ident
2182    }
2183}
2184#[cfg(feature = "full")]
2185#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2186impl Eq for crate::UsePath {}
2187#[cfg(feature = "full")]
2188#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2189impl PartialEq for crate::UsePath {
2190    fn eq(&self, other: &Self) -> bool {
2191        self.ident == other.ident && self.tree == other.tree
2192    }
2193}
2194#[cfg(feature = "full")]
2195#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2196impl Eq for crate::UseRename {}
2197#[cfg(feature = "full")]
2198#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2199impl PartialEq for crate::UseRename {
2200    fn eq(&self, other: &Self) -> bool {
2201        self.ident == other.ident && self.rename == other.rename
2202    }
2203}
2204#[cfg(feature = "full")]
2205#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2206impl Eq for crate::UseTree {}
2207#[cfg(feature = "full")]
2208#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2209impl PartialEq for crate::UseTree {
2210    fn eq(&self, other: &Self) -> bool {
2211        match (self, other) {
2212            (crate::UseTree::Path(self0), crate::UseTree::Path(other0)) => {
2213                self0 == other0
2214            }
2215            (crate::UseTree::Name(self0), crate::UseTree::Name(other0)) => {
2216                self0 == other0
2217            }
2218            (crate::UseTree::Rename(self0), crate::UseTree::Rename(other0)) => {
2219                self0 == other0
2220            }
2221            (crate::UseTree::Glob(self0), crate::UseTree::Glob(other0)) => {
2222                self0 == other0
2223            }
2224            (crate::UseTree::Group(self0), crate::UseTree::Group(other0)) => {
2225                self0 == other0
2226            }
2227            _ => false,
2228        }
2229    }
2230}
2231#[cfg(feature = "full")]
2232#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2233impl Eq for crate::Variadic {}
2234#[cfg(feature = "full")]
2235#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2236impl PartialEq for crate::Variadic {
2237    fn eq(&self, other: &Self) -> bool {
2238        self.attrs == other.attrs && self.pat == other.pat && self.comma == other.comma
2239    }
2240}
2241#[cfg(any(feature = "derive", feature = "full"))]
2242#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2243impl Eq for crate::Variant {}
2244#[cfg(any(feature = "derive", feature = "full"))]
2245#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2246impl PartialEq for crate::Variant {
2247    fn eq(&self, other: &Self) -> bool {
2248        self.attrs == other.attrs && self.ident == other.ident
2249            && self.fields == other.fields && self.discriminant == other.discriminant
2250    }
2251}
2252#[cfg(any(feature = "derive", feature = "full"))]
2253#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2254impl Eq for crate::VisRestricted {}
2255#[cfg(any(feature = "derive", feature = "full"))]
2256#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2257impl PartialEq for crate::VisRestricted {
2258    fn eq(&self, other: &Self) -> bool {
2259        self.in_token == other.in_token && self.path == other.path
2260    }
2261}
2262#[cfg(any(feature = "derive", feature = "full"))]
2263#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2264impl Eq for crate::Visibility {}
2265#[cfg(any(feature = "derive", feature = "full"))]
2266#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2267impl PartialEq for crate::Visibility {
2268    fn eq(&self, other: &Self) -> bool {
2269        match (self, other) {
2270            (crate::Visibility::Public(_), crate::Visibility::Public(_)) => true,
2271            (
2272                crate::Visibility::Restricted(self0),
2273                crate::Visibility::Restricted(other0),
2274            ) => self0 == other0,
2275            (crate::Visibility::Inherited, crate::Visibility::Inherited) => true,
2276            _ => false,
2277        }
2278    }
2279}
2280#[cfg(any(feature = "derive", feature = "full"))]
2281#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2282impl Eq for crate::WhereClause {}
2283#[cfg(any(feature = "derive", feature = "full"))]
2284#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2285impl PartialEq for crate::WhereClause {
2286    fn eq(&self, other: &Self) -> bool {
2287        self.predicates == other.predicates
2288    }
2289}
2290#[cfg(any(feature = "derive", feature = "full"))]
2291#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2292impl Eq for crate::WherePredicate {}
2293#[cfg(any(feature = "derive", feature = "full"))]
2294#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2295impl PartialEq for crate::WherePredicate {
2296    fn eq(&self, other: &Self) -> bool {
2297        match (self, other) {
2298            (
2299                crate::WherePredicate::Lifetime(self0),
2300                crate::WherePredicate::Lifetime(other0),
2301            ) => self0 == other0,
2302            (crate::WherePredicate::Type(self0), crate::WherePredicate::Type(other0)) => {
2303                self0 == other0
2304            }
2305            _ => false,
2306        }
2307    }
2308}
~/ Read-only file preview.