($key:ident($ast:ident) {

$($variant:ident $(($ignored:pat))? $(=> $fields:ident)?,)*

}) => {

impl PartialEq for $key<'_> {

fn eq(&self, other: &Self) -> bool {

match self.0 {

$(

$(ast::$ast::$variant(left) => match other.0 {

ast::$ast::$variant(right) => $fields(left) == $fields(right),

_ => false,

},)?

$(ast::$ast::$variant($ignored) => matches!(other.0, ast::$ast::$variant(_)),)?

)*

}

}

}

impl Eq for $key<'_> {}

impl Hash for $key<'_> {

fn hash<H: Hasher>(&self, state: &mut H) {

std::mem::discriminant::<ast::$ast>(&self.0).hash(state);

match self.0 {

$(

$(ast::$ast::$variant(node) => $fields(node).hash(state),)?

$(ast::$ast::$variant($ignored) => {},)?

)*

}

}

}

impl fmt::Debug for $key<'_> {

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

match self.0 {

$(

$(ast::$ast::$variant(node) => f

.debug_tuple(stringify!($variant))

.field(&$fields(node))

.finish(),)?

$(ast::$ast::$variant($ignored) => f.write_str(stringify!($variant)),)?

)*

}

}

}

};

fn from(alias: &'a ast::Alias) -> Self {

let ast::Alias {

name,

asname,

range: _,

node_index: _,

} = alias;

Self {

name: name.as_str(),

asname: asname.as_deref(),

}

}

fn from(with_item: &'a ast::WithItem) -> Self {

let ast::WithItem {

context_expr,

optional_vars,

range: _,

node_index: _,

} = with_item;

Self {

context_expr: context_expr.into(),

optional_vars: optional_vars.as_ref().map(Into::into),

}

}

fn from(keyword: &'a ast::PatternKeyword) -> Self {

let ast::PatternKeyword {

attr,

pattern,

range: _,

node_index: _,

} = keyword;

Self {

attr: attr.as_str(),

pattern: pattern.into(),

}

}

fn from(node: &'a ast::Pattern) -> Self {

Self(node)

}

let ast::PatternMatchValue {

value,

range: _,

node_index: _,

} = node;

value.into()

let ast::PatternMatchSingleton {

value,

range: _,

node_index: _,

} = node;

*value

let ast::PatternMatchSequence {

runtime_patterns: _,

patterns,

range: _,

node_index: _,

} = node;

ComparableSlice::new(patterns)

keys: ComparableExprSlice<'a>,

patterns: ComparablePatternSlice<'a>,

rest: Option<&'a str>,

let ast::PatternMatchMapping {

runtime_keys: _,

runtime_patterns: _,

keys,

patterns,

rest,

range: _,

node_index: _,

} = node;

MatchMappingFields {

keys: ComparableSlice::new(keys),

patterns: ComparableSlice::new(patterns),

rest: rest.as_deref(),

}

cls: ComparableExpr<'a>,

patterns: ComparablePatternSlice<'a>,

keywords: ComparableSlice<'a, ast::PatternKeyword, ComparablePatternKeyword<'a>>,

let ast::PatternMatchClass {

runtime_patterns: _,

runtime_kwd_attrs: _,

runtime_kwd_patterns: _,

cls,

arguments:

ast::PatternArguments {

patterns,

keywords,

range: _,

node_index: _,

},

range: _,

node_index: _,

} = node;

MatchClassFields {

cls: cls.into(),

patterns: ComparableSlice::new(patterns),

keywords: ComparableSlice::new(keywords),

}

let ast::PatternMatchStar {

name,

range: _,

node_index: _,

} = node;

name.as_deref()

let ast::PatternMatchAs {

pattern,

name,

range: _,

node_index: _,

} = node;

MatchAsFields {

pattern: pattern.as_deref().map(Into::into),

name: name.as_deref(),

}

let ast::PatternMatchOr {

runtime_patterns: _,

patterns,

range: _,

node_index: _,

} = node;

ComparableSlice::new(patterns)

pattern: ComparablePattern<'a>,

guard: Option<ComparableExpr<'a>>,

body: ComparableStmtSlice<'a>,

fn from(match_case: &'a ast::MatchCase) -> Self {

let ast::MatchCase {

runtime_body: _,

pattern,

guard,

body,

range: _,

node_index: _,

} = match_case;

Self {

pattern: pattern.into(),

guard: guard.as_ref().map(Into::into),

body: ComparableSlice::new(body),

}

}

fn from(decorator: &'a ast::Decorator) -> Self {

let ast::Decorator {

expression,

range: _,

node_index: _,

} = decorator;

expression.into()

}

fn from(identifier: &'a ast::Identifier) -> Self {

let ast::Identifier {

id,

range: _,

node_index: _,

} = identifier;

Self(id.as_str())

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

self.0.fmt(f)

}

fn eq(&self, other: &Self) -> bool {

match self.0 {

ast::Number::Int(left) => matches!(other.0, ast::Number::Int(right) if left == right),

ast::Number::Float(left) => {

matches!(other.0, ast::Number::Float(right) if left.to_bits() == right.to_bits())

}

ast::Number::Complex { real, imag } => match other.0 {

ast::Number::Complex {

real: other_real,

imag: other_imag,

} => {

real.to_bits() == other_real.to_bits() && imag.to_bits() == other_imag.to_bits()

}

_ => false,

},

}

}

fn hash<H: Hasher>(&self, state: &mut H) {

std::mem::discriminant(self.0).hash(state);

match self.0 {

ast::Number::Int(value) => value.hash(state),

ast::Number::Float(value) => value.to_bits().hash(state),

ast::Number::Complex { real, imag } => (real.to_bits(), imag.to_bits()).hash(state),

}

}

None,

Boolean(bool),

Str(&'a str),

Bytes(Cow<'a, [u8]>),

Integer(&'a str),

Tuple(Vec<Self>),

Frozenset(Vec<Self>),

Float(u64),

Complex { real: u64, imag: u64 },

Ellipsis,

fn from(value: &'a ConstantValue) -> Self {

match value {

ConstantValue::None => Self::None,

ConstantValue::Boolean(value) => Self::Boolean(*value),

ConstantValue::Str(value) => Self::Str(value),

ConstantValue::Bytes(value) => Self::Bytes(Cow::from(value.as_ref())),

ConstantValue::Integer(value) => Self::Integer(value),

ConstantValue::Tuple(elements) => {

Self::Tuple(elements.iter().map(Into::into).collect())

}

ConstantValue::Frozenset(elements) => {

Self::Frozenset(elements.iter().map(Into::into).collect())

}

ConstantValue::Float(value) => Self::Float(value.to_bits()),

ConstantValue::Complex { real, imag } => Self::Complex {

real: real.to_bits(),

imag: imag.to_bits(),

},

ConstantValue::Ellipsis => Self::Ellipsis,

}

}

fn new(items: &'a [T]) -> Self {

Self {

items,

comparable: PhantomData,

}

}

fn iter(&self) -> impl Iterator<Item = C>

where

C: From<&'a T>,

{

self.items.iter().map(C::from)

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

f.debug_list().entries(self.iter()).finish()

}

fn default() -> Self {

Self::new(&[])

}

fn eq(&self, other: &Self) -> bool {

self.items.len() == other.items.len() && self.iter().eq(other.iter())

}

fn hash<H: Hasher>(&self, state: &mut H) {

self.items.len().hash(state);

for item in self.iter() {

item.hash(state);

}

}

fn from(arguments: &'a ast::Arguments) -> Self {

let ast::Arguments {

runtime_args: _,

runtime_bases: _,

args,

keywords,

range: _,

node_index: _,

} = arguments;

Self {

args: ComparableSlice::new(args),

keywords: ComparableSlice::new(keywords),

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

ComparableParametersFields::from(self.0).fmt(f)

}

fn eq(&self, other: &Self) -> bool {

ComparableParametersFields::from(self.0) == ComparableParametersFields::from(other.0)

}

fn hash<H: Hasher>(&self, state: &mut H) {

ComparableParametersFields::from(self.0).hash(state);

}

posonlyargs: ComparableSlice<'a, ast::ParameterWithDefault, ComparableParameterWithDefault<'a>>,

args: ComparableSlice<'a, ast::ParameterWithDefault, ComparableParameterWithDefault<'a>>,

vararg: Option<ComparableParameter<'a>>,

kwonlyargs: ComparableSlice<'a, ast::ParameterWithDefault, ComparableParameterWithDefault<'a>>,

kwarg: Option<ComparableParameter<'a>>,

fn from(parameters: &'a ast::Parameters) -> Self {

let ast::Parameters {

runtime_defaults: _,

posonlyargs,

args,

vararg,

kwonlyargs,

kwarg,

range: _,

node_index: _,

} = parameters;

Self {

posonlyargs: ComparableSlice::new(posonlyargs),

args: ComparableSlice::new(args),

vararg: vararg.as_deref().map(Into::into),

kwonlyargs: ComparableSlice::new(kwonlyargs),

kwarg: kwarg.as_deref().map(Into::into),

}

}

fn from(arg: &'a ast::Parameter) -> Self {

let ast::Parameter {

runtime_type_comment: _,

runtime_type_comment_bytes: _,

name,

annotation,

range: _,

node_index: _,

} = arg;

Self {

arg: name.as_str(),

annotation: annotation.as_ref().map(Into::into),

}

}

fn from(arg: &'a ast::ParameterWithDefault) -> Self {

let ast::ParameterWithDefault {

parameter,

default,

range: _,

node_index: _,

} = arg;

Self {

def: parameter.into(),

default: default.as_ref().map(Into::into),

}

}

fn from(keyword: &'a ast::Keyword) -> Self {

let ast::Keyword {

arg,

value,

range: _,

node_index: _,

} = keyword;

Self {

arg: arg.as_ref().map(ast::Identifier::as_str),

value: value.into(),

}

}

target: ComparableExpr<'a>,

iter: ComparableExpr<'a>,

ifs: ComparableExprSlice<'a>,

is_async: bool,

fn from(comprehension: &'a ast::Comprehension) -> Self {

let ast::Comprehension {

runtime_ifs: _,

runtime_is_async: _,

target,

iter,

ifs,

is_async,

range: _,

node_index: _,

} = comprehension;

Self {

target: target.into(),

iter: iter.into(),

ifs: ComparableSlice::new(ifs),

is_async: *is_async,

}

}

type_: Option<ComparableExpr<'a>>,

name: Option<&'a str>,

body: ComparableStmtSlice<'a>,

fn from(except_handler: &'a ast::ExceptHandler) -> Self {

let ast::ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {

runtime_body: _,

type_,

name,

body,

range: _,

node_index: _,

}) = except_handler;

Self {

type_: type_.as_ref().map(Into::into),

name: name.as_deref(),

body: ComparableSlice::new(body),

}

}

/// Coalesce adjacent literals so that part boundaries do not affect comparison.

/// For example, `f"{foo!r} one" " and two " f" and three {bar!s}"` decomposes into

///

/// - An f-string part with the interpolation `{foo!r}` and the literal `" one"`.

/// - A plain string literal part containing `" and two "`.

/// - An f-string part with the literal `" and three "` and the interpolation `{bar!s}`.

///

/// All three pieces of literal text form one comparable element between the

/// two interpolations. Equality compares these elements in order, and hashing

/// visits the same sequence.

///

/// [CPython's `string.templatelib.Template`] has one more string than interpolation.

/// Interleaving the two sequences, starting with a string, recovers the reading

/// order. For example, `t"{foo}bar"` has string slots `("", "bar")`, while

/// `t"bar{foo}"` has `("bar", "")`. Here the interpolations already delimit

/// the slots, so we can omit empty t-string text. For f-strings, an explicit

/// empty literal part still participates in comparison, as in `f"{foo}" ""`.

///

/// [CPython's `string.templatelib.Template`]: https://github.com/python/cpython/blob/c91ad5da9d92eac4718e4da8d53689c3cc24535e/Python/codegen.c#L4052-L4103

fn normalized_elements(self) -> impl Iterator<Item = ComparableStringElement<'a>> {

let mut raw = self.raw_elements().peekable();

std::iter::from_fn(move || {

loop {

match raw.next()? {

element @ ComparableStringElement::Interpolation(_) => {

return Some(element);

}

ComparableStringElement::Literal(mut text) => {

// In `f"{x}a" "b"`, after the interpolation, `raw.next()`

// returns `Literal(Cow::Borrowed("a"))` by value. The pattern

// moves the `Cow` into the mutable local variable `text`.

// Its `&str` points into the AST. `text += next` appends "b" by

// replacing the local `Cow` with an owned `String` containing "ab".

// In `f"{x}ab"`, "ab" stays borrowed and compares equal by content.

while let Some(ComparableStringElement::Literal(next)) =

raw.next_if(|next| matches!(next, ComparableStringElement::Literal(_)))

{

text += next;

}

if !text.is_empty() || matches!(self, Self::FString(_)) {

return Some(ComparableStringElement::Literal(text));

}

}

}

}

})

}

/// Flatten the parts in source order. Each element borrows from the AST,

/// and adjacent literal pieces are still separate at this point.

fn raw_elements(self) -> impl Iterator<Item = ComparableStringElement<'a>> {

enum Parts<'a> {

FString(ast::FStringParts<'a>),

TString(std::slice::Iter<'a, ast::TString>),

}

let mut parts = match self {

Self::FString(value) => Parts::FString(value.iter()),

Self::TString(value) => Parts::TString(value.as_slice().iter()),

};

let mut elements = [].iter();

std::iter::from_fn(move || {

loop {

if let Some(element) = elements.next() {

return Some(ComparableStringElement::from(element));

}

elements = match &mut parts {

Parts::FString(parts) => match parts.next()? {

ast::FStringPartRef::FString(ast::FString {

elements,

range: _,

node_index: _,

flags: _,

}) => elements.iter(),

ast::FStringPartRef::Literal(part) => {

return Some(ComparableStringElement::Literal(Cow::Borrowed(

ComparableText::from(part).0,

)));

}

},

Parts::TString(parts) => {

let ast::TString {

elements,

range: _,

node_index: _,

flags: _,

} = parts.next()?;

elements.iter()

}

};

}

})

}

fn eq(&self, other: &Self) -> bool {