mirror of https://github.com/torvalds/linux.git
2879 lines
75 KiB
Rust
2879 lines
75 KiB
Rust
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
|
|
// This file is @generated by syn-internal-codegen.
|
|
// It is not intended for manual editing.
|
|
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
use crate::tt::TokenStreamHelper;
|
|
use std::hash::{Hash, Hasher};
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Abi {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.name.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::AngleBracketedGenericArguments {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.colon2_token.hash(state);
|
|
self.args.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Arm {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.pat.hash(state);
|
|
self.guard.hash(state);
|
|
self.body.hash(state);
|
|
self.comma.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::AssocConst {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.value.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::AssocType {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.ty.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::AttrStyle {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::AttrStyle::Outer => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::AttrStyle::Inner(_) => {
|
|
state.write_u8(1u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Attribute {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.style.hash(state);
|
|
self.meta.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::BareFnArg {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.name.hash(state);
|
|
self.ty.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::BareVariadic {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.name.hash(state);
|
|
self.comma.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::BinOp {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::BinOp::Add(_) => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::BinOp::Sub(_) => {
|
|
state.write_u8(1u8);
|
|
}
|
|
crate::BinOp::Mul(_) => {
|
|
state.write_u8(2u8);
|
|
}
|
|
crate::BinOp::Div(_) => {
|
|
state.write_u8(3u8);
|
|
}
|
|
crate::BinOp::Rem(_) => {
|
|
state.write_u8(4u8);
|
|
}
|
|
crate::BinOp::And(_) => {
|
|
state.write_u8(5u8);
|
|
}
|
|
crate::BinOp::Or(_) => {
|
|
state.write_u8(6u8);
|
|
}
|
|
crate::BinOp::BitXor(_) => {
|
|
state.write_u8(7u8);
|
|
}
|
|
crate::BinOp::BitAnd(_) => {
|
|
state.write_u8(8u8);
|
|
}
|
|
crate::BinOp::BitOr(_) => {
|
|
state.write_u8(9u8);
|
|
}
|
|
crate::BinOp::Shl(_) => {
|
|
state.write_u8(10u8);
|
|
}
|
|
crate::BinOp::Shr(_) => {
|
|
state.write_u8(11u8);
|
|
}
|
|
crate::BinOp::Eq(_) => {
|
|
state.write_u8(12u8);
|
|
}
|
|
crate::BinOp::Lt(_) => {
|
|
state.write_u8(13u8);
|
|
}
|
|
crate::BinOp::Le(_) => {
|
|
state.write_u8(14u8);
|
|
}
|
|
crate::BinOp::Ne(_) => {
|
|
state.write_u8(15u8);
|
|
}
|
|
crate::BinOp::Ge(_) => {
|
|
state.write_u8(16u8);
|
|
}
|
|
crate::BinOp::Gt(_) => {
|
|
state.write_u8(17u8);
|
|
}
|
|
crate::BinOp::AddAssign(_) => {
|
|
state.write_u8(18u8);
|
|
}
|
|
crate::BinOp::SubAssign(_) => {
|
|
state.write_u8(19u8);
|
|
}
|
|
crate::BinOp::MulAssign(_) => {
|
|
state.write_u8(20u8);
|
|
}
|
|
crate::BinOp::DivAssign(_) => {
|
|
state.write_u8(21u8);
|
|
}
|
|
crate::BinOp::RemAssign(_) => {
|
|
state.write_u8(22u8);
|
|
}
|
|
crate::BinOp::BitXorAssign(_) => {
|
|
state.write_u8(23u8);
|
|
}
|
|
crate::BinOp::BitAndAssign(_) => {
|
|
state.write_u8(24u8);
|
|
}
|
|
crate::BinOp::BitOrAssign(_) => {
|
|
state.write_u8(25u8);
|
|
}
|
|
crate::BinOp::ShlAssign(_) => {
|
|
state.write_u8(26u8);
|
|
}
|
|
crate::BinOp::ShrAssign(_) => {
|
|
state.write_u8(27u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Block {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.stmts.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::BoundLifetimes {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.lifetimes.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::CapturedParam {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::CapturedParam::Lifetime(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::CapturedParam::Ident(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ConstParam {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.ident.hash(state);
|
|
self.ty.hash(state);
|
|
self.eq_token.hash(state);
|
|
self.default.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Constraint {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.bounds.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "derive")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Data {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::Data::Struct(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Data::Enum(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Data::Union(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "derive")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::DataEnum {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.variants.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "derive")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::DataStruct {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.fields.hash(state);
|
|
self.semi_token.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "derive")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::DataUnion {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.fields.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "derive")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::DeriveInput {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.data.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Expr {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Array(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Assign(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Async(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Await(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Binary(v0) => {
|
|
state.write_u8(4u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Block(v0) => {
|
|
state.write_u8(5u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Break(v0) => {
|
|
state.write_u8(6u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Call(v0) => {
|
|
state.write_u8(7u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Cast(v0) => {
|
|
state.write_u8(8u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Closure(v0) => {
|
|
state.write_u8(9u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Const(v0) => {
|
|
state.write_u8(10u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Continue(v0) => {
|
|
state.write_u8(11u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Field(v0) => {
|
|
state.write_u8(12u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::ForLoop(v0) => {
|
|
state.write_u8(13u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Group(v0) => {
|
|
state.write_u8(14u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::If(v0) => {
|
|
state.write_u8(15u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Index(v0) => {
|
|
state.write_u8(16u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Infer(v0) => {
|
|
state.write_u8(17u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Let(v0) => {
|
|
state.write_u8(18u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Lit(v0) => {
|
|
state.write_u8(19u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Loop(v0) => {
|
|
state.write_u8(20u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Macro(v0) => {
|
|
state.write_u8(21u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Match(v0) => {
|
|
state.write_u8(22u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::MethodCall(v0) => {
|
|
state.write_u8(23u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Paren(v0) => {
|
|
state.write_u8(24u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Path(v0) => {
|
|
state.write_u8(25u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Range(v0) => {
|
|
state.write_u8(26u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::RawAddr(v0) => {
|
|
state.write_u8(27u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Reference(v0) => {
|
|
state.write_u8(28u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Repeat(v0) => {
|
|
state.write_u8(29u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Return(v0) => {
|
|
state.write_u8(30u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Struct(v0) => {
|
|
state.write_u8(31u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Try(v0) => {
|
|
state.write_u8(32u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::TryBlock(v0) => {
|
|
state.write_u8(33u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Tuple(v0) => {
|
|
state.write_u8(34u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Unary(v0) => {
|
|
state.write_u8(35u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Unsafe(v0) => {
|
|
state.write_u8(36u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Expr::Verbatim(v0) => {
|
|
state.write_u8(37u8);
|
|
TokenStreamHelper(v0).hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::While(v0) => {
|
|
state.write_u8(38u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::Expr::Yield(v0) => {
|
|
state.write_u8(39u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(not(feature = "full"))]
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprArray {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.elems.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprAssign {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.left.hash(state);
|
|
self.right.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprAsync {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.capture.hash(state);
|
|
self.block.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprAwait {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.base.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprBinary {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.left.hash(state);
|
|
self.op.hash(state);
|
|
self.right.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprBlock {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.label.hash(state);
|
|
self.block.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprBreak {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.label.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprCall {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.func.hash(state);
|
|
self.args.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprCast {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.expr.hash(state);
|
|
self.ty.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprClosure {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.lifetimes.hash(state);
|
|
self.constness.hash(state);
|
|
self.movability.hash(state);
|
|
self.asyncness.hash(state);
|
|
self.capture.hash(state);
|
|
self.inputs.hash(state);
|
|
self.output.hash(state);
|
|
self.body.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprConst {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.block.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprContinue {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.label.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprField {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.base.hash(state);
|
|
self.member.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprForLoop {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.label.hash(state);
|
|
self.pat.hash(state);
|
|
self.expr.hash(state);
|
|
self.body.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprGroup {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprIf {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.cond.hash(state);
|
|
self.then_branch.hash(state);
|
|
self.else_branch.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprIndex {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.expr.hash(state);
|
|
self.index.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprInfer {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprLet {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.pat.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprLit {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.lit.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprLoop {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.label.hash(state);
|
|
self.body.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprMacro {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.mac.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprMatch {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.expr.hash(state);
|
|
self.arms.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprMethodCall {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.receiver.hash(state);
|
|
self.method.hash(state);
|
|
self.turbofish.hash(state);
|
|
self.args.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprParen {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprPath {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.qself.hash(state);
|
|
self.path.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprRange {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.start.hash(state);
|
|
self.limits.hash(state);
|
|
self.end.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprRawAddr {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.mutability.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprReference {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.mutability.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprRepeat {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.expr.hash(state);
|
|
self.len.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprReturn {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprStruct {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.qself.hash(state);
|
|
self.path.hash(state);
|
|
self.fields.hash(state);
|
|
self.dot2_token.hash(state);
|
|
self.rest.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprTry {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprTryBlock {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.block.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprTuple {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.elems.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprUnary {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.op.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprUnsafe {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.block.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprWhile {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.label.hash(state);
|
|
self.cond.hash(state);
|
|
self.body.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ExprYield {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Field {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.mutability.hash(state);
|
|
self.ident.hash(state);
|
|
self.colon_token.hash(state);
|
|
self.ty.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::FieldMutability {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::FieldMutability::None => {
|
|
state.write_u8(0u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::FieldPat {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.member.hash(state);
|
|
self.colon_token.hash(state);
|
|
self.pat.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::FieldValue {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.member.hash(state);
|
|
self.colon_token.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Fields {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::Fields::Named(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Fields::Unnamed(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Fields::Unit => {
|
|
state.write_u8(2u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::FieldsNamed {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.named.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::FieldsUnnamed {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.unnamed.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::File {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.shebang.hash(state);
|
|
self.attrs.hash(state);
|
|
self.items.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::FnArg {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::FnArg::Receiver(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::FnArg::Typed(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ForeignItem {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::ForeignItem::Fn(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::ForeignItem::Static(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::ForeignItem::Type(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::ForeignItem::Macro(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::ForeignItem::Verbatim(v0) => {
|
|
state.write_u8(4u8);
|
|
TokenStreamHelper(v0).hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ForeignItemFn {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.sig.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ForeignItemMacro {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.mac.hash(state);
|
|
self.semi_token.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ForeignItemStatic {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.mutability.hash(state);
|
|
self.ident.hash(state);
|
|
self.ty.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ForeignItemType {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::GenericArgument {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::GenericArgument::Lifetime(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::GenericArgument::Type(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::GenericArgument::Const(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::GenericArgument::AssocType(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::GenericArgument::AssocConst(v0) => {
|
|
state.write_u8(4u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::GenericArgument::Constraint(v0) => {
|
|
state.write_u8(5u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::GenericParam {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::GenericParam::Lifetime(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::GenericParam::Type(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::GenericParam::Const(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Generics {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.lt_token.hash(state);
|
|
self.params.hash(state);
|
|
self.gt_token.hash(state);
|
|
self.where_clause.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ImplItem {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::ImplItem::Const(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::ImplItem::Fn(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::ImplItem::Type(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::ImplItem::Macro(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::ImplItem::Verbatim(v0) => {
|
|
state.write_u8(4u8);
|
|
TokenStreamHelper(v0).hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ImplItemConst {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.defaultness.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.ty.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ImplItemFn {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.defaultness.hash(state);
|
|
self.sig.hash(state);
|
|
self.block.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ImplItemMacro {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.mac.hash(state);
|
|
self.semi_token.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ImplItemType {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.defaultness.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.ty.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ImplRestriction {
|
|
fn hash<H>(&self, _state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match *self {}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Item {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::Item::Const(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Enum(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::ExternCrate(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Fn(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::ForeignMod(v0) => {
|
|
state.write_u8(4u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Impl(v0) => {
|
|
state.write_u8(5u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Macro(v0) => {
|
|
state.write_u8(6u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Mod(v0) => {
|
|
state.write_u8(7u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Static(v0) => {
|
|
state.write_u8(8u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Struct(v0) => {
|
|
state.write_u8(9u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Trait(v0) => {
|
|
state.write_u8(10u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::TraitAlias(v0) => {
|
|
state.write_u8(11u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Type(v0) => {
|
|
state.write_u8(12u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Union(v0) => {
|
|
state.write_u8(13u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Use(v0) => {
|
|
state.write_u8(14u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Item::Verbatim(v0) => {
|
|
state.write_u8(15u8);
|
|
TokenStreamHelper(v0).hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemConst {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.ty.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemEnum {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.variants.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemExternCrate {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.ident.hash(state);
|
|
self.rename.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemFn {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.sig.hash(state);
|
|
self.block.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemForeignMod {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.unsafety.hash(state);
|
|
self.abi.hash(state);
|
|
self.items.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemImpl {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.defaultness.hash(state);
|
|
self.unsafety.hash(state);
|
|
self.generics.hash(state);
|
|
self.trait_.hash(state);
|
|
self.self_ty.hash(state);
|
|
self.items.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemMacro {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.ident.hash(state);
|
|
self.mac.hash(state);
|
|
self.semi_token.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemMod {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.unsafety.hash(state);
|
|
self.ident.hash(state);
|
|
self.content.hash(state);
|
|
self.semi.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemStatic {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.mutability.hash(state);
|
|
self.ident.hash(state);
|
|
self.ty.hash(state);
|
|
self.expr.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemStruct {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.fields.hash(state);
|
|
self.semi_token.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemTrait {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.unsafety.hash(state);
|
|
self.auto_token.hash(state);
|
|
self.restriction.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.colon_token.hash(state);
|
|
self.supertraits.hash(state);
|
|
self.items.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemTraitAlias {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.bounds.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemType {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.ty.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemUnion {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.fields.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ItemUse {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.vis.hash(state);
|
|
self.leading_colon.hash(state);
|
|
self.tree.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Label {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.name.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::LifetimeParam {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.lifetime.hash(state);
|
|
self.colon_token.hash(state);
|
|
self.bounds.hash(state);
|
|
}
|
|
}
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Lit {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::Lit::Str(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Lit::ByteStr(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Lit::CStr(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Lit::Byte(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Lit::Char(v0) => {
|
|
state.write_u8(4u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Lit::Int(v0) => {
|
|
state.write_u8(5u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Lit::Float(v0) => {
|
|
state.write_u8(6u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Lit::Bool(v0) => {
|
|
state.write_u8(7u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Lit::Verbatim(v0) => {
|
|
state.write_u8(8u8);
|
|
v0.to_string().hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::LitBool {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.value.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Local {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.pat.hash(state);
|
|
self.init.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::LocalInit {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.expr.hash(state);
|
|
self.diverge.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Macro {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.path.hash(state);
|
|
self.delimiter.hash(state);
|
|
TokenStreamHelper(&self.tokens).hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::MacroDelimiter {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::MacroDelimiter::Paren(_) => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::MacroDelimiter::Brace(_) => {
|
|
state.write_u8(1u8);
|
|
}
|
|
crate::MacroDelimiter::Bracket(_) => {
|
|
state.write_u8(2u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Meta {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::Meta::Path(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Meta::List(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Meta::NameValue(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::MetaList {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.path.hash(state);
|
|
self.delimiter.hash(state);
|
|
TokenStreamHelper(&self.tokens).hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::MetaNameValue {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.path.hash(state);
|
|
self.value.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ParenthesizedGenericArguments {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.inputs.hash(state);
|
|
self.output.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Pat {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::Pat::Const(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Ident(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Lit(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Macro(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Or(v0) => {
|
|
state.write_u8(4u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Paren(v0) => {
|
|
state.write_u8(5u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Path(v0) => {
|
|
state.write_u8(6u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Range(v0) => {
|
|
state.write_u8(7u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Reference(v0) => {
|
|
state.write_u8(8u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Rest(v0) => {
|
|
state.write_u8(9u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Slice(v0) => {
|
|
state.write_u8(10u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Struct(v0) => {
|
|
state.write_u8(11u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Tuple(v0) => {
|
|
state.write_u8(12u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::TupleStruct(v0) => {
|
|
state.write_u8(13u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Type(v0) => {
|
|
state.write_u8(14u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Pat::Verbatim(v0) => {
|
|
state.write_u8(15u8);
|
|
TokenStreamHelper(v0).hash(state);
|
|
}
|
|
crate::Pat::Wild(v0) => {
|
|
state.write_u8(16u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatIdent {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.by_ref.hash(state);
|
|
self.mutability.hash(state);
|
|
self.ident.hash(state);
|
|
self.subpat.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatOr {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.leading_vert.hash(state);
|
|
self.cases.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatParen {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.pat.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatReference {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.mutability.hash(state);
|
|
self.pat.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatRest {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatSlice {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.elems.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatStruct {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.qself.hash(state);
|
|
self.path.hash(state);
|
|
self.fields.hash(state);
|
|
self.rest.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatTuple {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.elems.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatTupleStruct {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.qself.hash(state);
|
|
self.path.hash(state);
|
|
self.elems.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatType {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.pat.hash(state);
|
|
self.ty.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PatWild {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Path {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.leading_colon.hash(state);
|
|
self.segments.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PathArguments {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::PathArguments::None => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::PathArguments::AngleBracketed(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::PathArguments::Parenthesized(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PathSegment {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.ident.hash(state);
|
|
self.arguments.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PointerMutability {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::PointerMutability::Const(_) => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::PointerMutability::Mut(_) => {
|
|
state.write_u8(1u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PreciseCapture {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.params.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PredicateLifetime {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.lifetime.hash(state);
|
|
self.bounds.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::PredicateType {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.lifetimes.hash(state);
|
|
self.bounded_ty.hash(state);
|
|
self.bounds.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::QSelf {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.ty.hash(state);
|
|
self.position.hash(state);
|
|
self.as_token.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::RangeLimits {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::RangeLimits::HalfOpen(_) => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::RangeLimits::Closed(_) => {
|
|
state.write_u8(1u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Receiver {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.reference.hash(state);
|
|
self.mutability.hash(state);
|
|
self.colon_token.hash(state);
|
|
self.ty.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::ReturnType {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::ReturnType::Default => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::ReturnType::Type(_, v1) => {
|
|
state.write_u8(1u8);
|
|
v1.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Signature {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.constness.hash(state);
|
|
self.asyncness.hash(state);
|
|
self.unsafety.hash(state);
|
|
self.abi.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.inputs.hash(state);
|
|
self.variadic.hash(state);
|
|
self.output.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::StaticMutability {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::StaticMutability::Mut(_) => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::StaticMutability::None => {
|
|
state.write_u8(1u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Stmt {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::Stmt::Local(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Stmt::Item(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Stmt::Expr(v0, v1) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
v1.hash(state);
|
|
}
|
|
crate::Stmt::Macro(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::StmtMacro {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.mac.hash(state);
|
|
self.semi_token.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TraitBound {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.paren_token.hash(state);
|
|
self.modifier.hash(state);
|
|
self.lifetimes.hash(state);
|
|
self.path.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TraitBoundModifier {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::TraitBoundModifier::None => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::TraitBoundModifier::Maybe(_) => {
|
|
state.write_u8(1u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TraitItem {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::TraitItem::Const(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::TraitItem::Fn(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::TraitItem::Type(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::TraitItem::Macro(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::TraitItem::Verbatim(v0) => {
|
|
state.write_u8(4u8);
|
|
TokenStreamHelper(v0).hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TraitItemConst {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.ty.hash(state);
|
|
self.default.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TraitItemFn {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.sig.hash(state);
|
|
self.default.hash(state);
|
|
self.semi_token.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TraitItemMacro {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.mac.hash(state);
|
|
self.semi_token.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TraitItemType {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.ident.hash(state);
|
|
self.generics.hash(state);
|
|
self.colon_token.hash(state);
|
|
self.bounds.hash(state);
|
|
self.default.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Type {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::Type::Array(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::BareFn(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Group(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::ImplTrait(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Infer(v0) => {
|
|
state.write_u8(4u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Macro(v0) => {
|
|
state.write_u8(5u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Never(v0) => {
|
|
state.write_u8(6u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Paren(v0) => {
|
|
state.write_u8(7u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Path(v0) => {
|
|
state.write_u8(8u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Ptr(v0) => {
|
|
state.write_u8(9u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Reference(v0) => {
|
|
state.write_u8(10u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Slice(v0) => {
|
|
state.write_u8(11u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::TraitObject(v0) => {
|
|
state.write_u8(12u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Tuple(v0) => {
|
|
state.write_u8(13u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Type::Verbatim(v0) => {
|
|
state.write_u8(14u8);
|
|
TokenStreamHelper(v0).hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeArray {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.elem.hash(state);
|
|
self.len.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeBareFn {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.lifetimes.hash(state);
|
|
self.unsafety.hash(state);
|
|
self.abi.hash(state);
|
|
self.inputs.hash(state);
|
|
self.variadic.hash(state);
|
|
self.output.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeGroup {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.elem.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeImplTrait {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.bounds.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeInfer {
|
|
fn hash<H>(&self, _state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeMacro {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.mac.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeNever {
|
|
fn hash<H>(&self, _state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeParam {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.ident.hash(state);
|
|
self.colon_token.hash(state);
|
|
self.bounds.hash(state);
|
|
self.eq_token.hash(state);
|
|
self.default.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeParamBound {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::TypeParamBound::Trait(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::TypeParamBound::Lifetime(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
#[cfg(feature = "full")]
|
|
crate::TypeParamBound::PreciseCapture(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::TypeParamBound::Verbatim(v0) => {
|
|
state.write_u8(3u8);
|
|
TokenStreamHelper(v0).hash(state);
|
|
}
|
|
#[cfg(not(feature = "full"))]
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeParen {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.elem.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypePath {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.qself.hash(state);
|
|
self.path.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypePtr {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.const_token.hash(state);
|
|
self.mutability.hash(state);
|
|
self.elem.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeReference {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.lifetime.hash(state);
|
|
self.mutability.hash(state);
|
|
self.elem.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeSlice {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.elem.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeTraitObject {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.dyn_token.hash(state);
|
|
self.bounds.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::TypeTuple {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.elems.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::UnOp {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::UnOp::Deref(_) => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::UnOp::Not(_) => {
|
|
state.write_u8(1u8);
|
|
}
|
|
crate::UnOp::Neg(_) => {
|
|
state.write_u8(2u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::UseGlob {
|
|
fn hash<H>(&self, _state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::UseGroup {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.items.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::UseName {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.ident.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::UsePath {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.ident.hash(state);
|
|
self.tree.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::UseRename {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.ident.hash(state);
|
|
self.rename.hash(state);
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::UseTree {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::UseTree::Path(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::UseTree::Name(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::UseTree::Rename(v0) => {
|
|
state.write_u8(2u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::UseTree::Glob(v0) => {
|
|
state.write_u8(3u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::UseTree::Group(v0) => {
|
|
state.write_u8(4u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(feature = "full")]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Variadic {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.pat.hash(state);
|
|
self.comma.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Variant {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.attrs.hash(state);
|
|
self.ident.hash(state);
|
|
self.fields.hash(state);
|
|
self.discriminant.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::VisRestricted {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.in_token.hash(state);
|
|
self.path.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::Visibility {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::Visibility::Public(_) => {
|
|
state.write_u8(0u8);
|
|
}
|
|
crate::Visibility::Restricted(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::Visibility::Inherited => {
|
|
state.write_u8(2u8);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::WhereClause {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
self.predicates.hash(state);
|
|
}
|
|
}
|
|
#[cfg(any(feature = "derive", feature = "full"))]
|
|
#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
|
|
impl Hash for crate::WherePredicate {
|
|
fn hash<H>(&self, state: &mut H)
|
|
where
|
|
H: Hasher,
|
|
{
|
|
match self {
|
|
crate::WherePredicate::Lifetime(v0) => {
|
|
state.write_u8(0u8);
|
|
v0.hash(state);
|
|
}
|
|
crate::WherePredicate::Type(v0) => {
|
|
state.write_u8(1u8);
|
|
v0.hash(state);
|
|
}
|
|
}
|
|
}
|
|
}
|