812 lines
29 KiB
Rust
812 lines
29 KiB
Rust
//! Builtin derives.
|
|
|
|
use itertools::izip;
|
|
use rustc_hash::FxHashSet;
|
|
use span::{MacroCallId, Span};
|
|
use stdx::never;
|
|
use tracing::debug;
|
|
|
|
use crate::{
|
|
hygiene::span_with_def_site_ctxt,
|
|
name::{AsName, Name},
|
|
quote::dollar_crate,
|
|
span_map::SpanMapRef,
|
|
tt,
|
|
};
|
|
use syntax::ast::{self, AstNode, FieldList, HasAttrs, HasGenericParams, HasName, HasTypeBounds};
|
|
|
|
use crate::{db::ExpandDatabase, name, quote, ExpandError, ExpandResult};
|
|
|
|
macro_rules! register_builtin {
|
|
( $($trait:ident => $expand:ident),* ) => {
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
pub enum BuiltinDeriveExpander {
|
|
$($trait),*
|
|
}
|
|
|
|
impl BuiltinDeriveExpander {
|
|
pub fn expand(
|
|
&self,
|
|
db: &dyn ExpandDatabase,
|
|
id: MacroCallId,
|
|
tt: &ast::Adt,
|
|
token_map: SpanMapRef<'_>,
|
|
) -> ExpandResult<tt::Subtree> {
|
|
let expander = match *self {
|
|
$( BuiltinDeriveExpander::$trait => $expand, )*
|
|
};
|
|
|
|
let span = db.lookup_intern_macro_call(id).call_site;
|
|
let span = span_with_def_site_ctxt(db, span, id);
|
|
expander(span, tt, token_map)
|
|
}
|
|
|
|
fn find_by_name(name: &name::Name) -> Option<Self> {
|
|
match name {
|
|
$( id if id == &name::name![$trait] => Some(BuiltinDeriveExpander::$trait), )*
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
register_builtin! {
|
|
Copy => copy_expand,
|
|
Clone => clone_expand,
|
|
Default => default_expand,
|
|
Debug => debug_expand,
|
|
Hash => hash_expand,
|
|
Ord => ord_expand,
|
|
PartialOrd => partial_ord_expand,
|
|
Eq => eq_expand,
|
|
PartialEq => partial_eq_expand
|
|
}
|
|
|
|
pub fn find_builtin_derive(ident: &name::Name) -> Option<BuiltinDeriveExpander> {
|
|
BuiltinDeriveExpander::find_by_name(ident)
|
|
}
|
|
|
|
enum VariantShape {
|
|
Struct(Vec<tt::Ident>),
|
|
Tuple(usize),
|
|
Unit,
|
|
}
|
|
|
|
fn tuple_field_iterator(span: Span, n: usize) -> impl Iterator<Item = tt::Ident> {
|
|
(0..n).map(move |it| tt::Ident::new(format!("f{it}"), span))
|
|
}
|
|
|
|
impl VariantShape {
|
|
fn as_pattern(&self, path: tt::Subtree, span: Span) -> tt::Subtree {
|
|
self.as_pattern_map(path, span, |it| quote!(span => #it))
|
|
}
|
|
|
|
fn field_names(&self, span: Span) -> Vec<tt::Ident> {
|
|
match self {
|
|
VariantShape::Struct(s) => s.clone(),
|
|
VariantShape::Tuple(n) => tuple_field_iterator(span, *n).collect(),
|
|
VariantShape::Unit => vec![],
|
|
}
|
|
}
|
|
|
|
fn as_pattern_map(
|
|
&self,
|
|
path: tt::Subtree,
|
|
span: Span,
|
|
field_map: impl Fn(&tt::Ident) -> tt::Subtree,
|
|
) -> tt::Subtree {
|
|
match self {
|
|
VariantShape::Struct(fields) => {
|
|
let fields = fields.iter().map(|it| {
|
|
let mapped = field_map(it);
|
|
quote! {span => #it : #mapped , }
|
|
});
|
|
quote! {span =>
|
|
#path { ##fields }
|
|
}
|
|
}
|
|
&VariantShape::Tuple(n) => {
|
|
let fields = tuple_field_iterator(span, n).map(|it| {
|
|
let mapped = field_map(&it);
|
|
quote! {span =>
|
|
#mapped ,
|
|
}
|
|
});
|
|
quote! {span =>
|
|
#path ( ##fields )
|
|
}
|
|
}
|
|
VariantShape::Unit => path,
|
|
}
|
|
}
|
|
|
|
fn from(tm: SpanMapRef<'_>, value: Option<FieldList>) -> Result<Self, ExpandError> {
|
|
let r = match value {
|
|
None => VariantShape::Unit,
|
|
Some(FieldList::RecordFieldList(it)) => VariantShape::Struct(
|
|
it.fields()
|
|
.map(|it| it.name())
|
|
.map(|it| name_to_token(tm, it))
|
|
.collect::<Result<_, _>>()?,
|
|
),
|
|
Some(FieldList::TupleFieldList(it)) => VariantShape::Tuple(it.fields().count()),
|
|
};
|
|
Ok(r)
|
|
}
|
|
}
|
|
|
|
enum AdtShape {
|
|
Struct(VariantShape),
|
|
Enum { variants: Vec<(tt::Ident, VariantShape)>, default_variant: Option<usize> },
|
|
Union,
|
|
}
|
|
|
|
impl AdtShape {
|
|
fn as_pattern(&self, span: Span, name: &tt::Ident) -> Vec<tt::Subtree> {
|
|
self.as_pattern_map(name, |it| quote!(span =>#it), span)
|
|
}
|
|
|
|
fn field_names(&self, span: Span) -> Vec<Vec<tt::Ident>> {
|
|
match self {
|
|
AdtShape::Struct(s) => {
|
|
vec![s.field_names(span)]
|
|
}
|
|
AdtShape::Enum { variants, .. } => {
|
|
variants.iter().map(|(_, fields)| fields.field_names(span)).collect()
|
|
}
|
|
AdtShape::Union => {
|
|
never!("using fields of union in derive is always wrong");
|
|
vec![]
|
|
}
|
|
}
|
|
}
|
|
|
|
fn as_pattern_map(
|
|
&self,
|
|
name: &tt::Ident,
|
|
field_map: impl Fn(&tt::Ident) -> tt::Subtree,
|
|
span: Span,
|
|
) -> Vec<tt::Subtree> {
|
|
match self {
|
|
AdtShape::Struct(s) => {
|
|
vec![s.as_pattern_map(quote! {span => #name }, span, field_map)]
|
|
}
|
|
AdtShape::Enum { variants, .. } => variants
|
|
.iter()
|
|
.map(|(v, fields)| {
|
|
fields.as_pattern_map(quote! {span => #name :: #v }, span, &field_map)
|
|
})
|
|
.collect(),
|
|
AdtShape::Union => {
|
|
never!("pattern matching on union is always wrong");
|
|
vec![quote! {span => un }]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct BasicAdtInfo {
|
|
name: tt::Ident,
|
|
shape: AdtShape,
|
|
/// first field is the name, and
|
|
/// second field is `Some(ty)` if it's a const param of type `ty`, `None` if it's a type param.
|
|
/// third fields is where bounds, if any
|
|
param_types: Vec<(tt::Subtree, Option<tt::Subtree>, Option<tt::Subtree>)>,
|
|
associated_types: Vec<tt::Subtree>,
|
|
}
|
|
|
|
fn parse_adt(
|
|
tm: SpanMapRef<'_>,
|
|
adt: &ast::Adt,
|
|
call_site: Span,
|
|
) -> Result<BasicAdtInfo, ExpandError> {
|
|
let (name, generic_param_list, shape) = match adt {
|
|
ast::Adt::Struct(it) => (
|
|
it.name(),
|
|
it.generic_param_list(),
|
|
AdtShape::Struct(VariantShape::from(tm, it.field_list())?),
|
|
),
|
|
ast::Adt::Enum(it) => {
|
|
let default_variant = it
|
|
.variant_list()
|
|
.into_iter()
|
|
.flat_map(|it| it.variants())
|
|
.position(|it| it.attrs().any(|it| it.simple_name() == Some("default".into())));
|
|
(
|
|
it.name(),
|
|
it.generic_param_list(),
|
|
AdtShape::Enum {
|
|
default_variant,
|
|
variants: it
|
|
.variant_list()
|
|
.into_iter()
|
|
.flat_map(|it| it.variants())
|
|
.map(|it| {
|
|
Ok((
|
|
name_to_token(tm, it.name())?,
|
|
VariantShape::from(tm, it.field_list())?,
|
|
))
|
|
})
|
|
.collect::<Result<_, ExpandError>>()?,
|
|
},
|
|
)
|
|
}
|
|
ast::Adt::Union(it) => (it.name(), it.generic_param_list(), AdtShape::Union),
|
|
};
|
|
|
|
let mut param_type_set: FxHashSet<Name> = FxHashSet::default();
|
|
let param_types = generic_param_list
|
|
.into_iter()
|
|
.flat_map(|param_list| param_list.type_or_const_params())
|
|
.map(|param| {
|
|
let name = {
|
|
let this = param.name();
|
|
match this {
|
|
Some(it) => {
|
|
param_type_set.insert(it.as_name());
|
|
mbe::syntax_node_to_token_tree(it.syntax(), tm, call_site)
|
|
}
|
|
None => {
|
|
tt::Subtree::empty(::tt::DelimSpan { open: call_site, close: call_site })
|
|
}
|
|
}
|
|
};
|
|
let bounds = match ¶m {
|
|
ast::TypeOrConstParam::Type(it) => it
|
|
.type_bound_list()
|
|
.map(|it| mbe::syntax_node_to_token_tree(it.syntax(), tm, call_site)),
|
|
ast::TypeOrConstParam::Const(_) => None,
|
|
};
|
|
let ty = if let ast::TypeOrConstParam::Const(param) = param {
|
|
let ty = param
|
|
.ty()
|
|
.map(|ty| mbe::syntax_node_to_token_tree(ty.syntax(), tm, call_site))
|
|
.unwrap_or_else(|| {
|
|
tt::Subtree::empty(::tt::DelimSpan { open: call_site, close: call_site })
|
|
});
|
|
Some(ty)
|
|
} else {
|
|
None
|
|
};
|
|
(name, ty, bounds)
|
|
})
|
|
.collect();
|
|
|
|
// For a generic parameter `T`, when shorthand associated type `T::Assoc` appears in field
|
|
// types (of any variant for enums), we generate trait bound for it. It sounds reasonable to
|
|
// also generate trait bound for qualified associated type `<T as Trait>::Assoc`, but rustc
|
|
// does not do that for some unknown reason.
|
|
//
|
|
// See the analogous function in rustc [find_type_parameters()] and rust-lang/rust#50730.
|
|
// [find_type_parameters()]: https://github.com/rust-lang/rust/blob/1.70.0/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs#L378
|
|
|
|
// It's cumbersome to deal with the distinct structures of ADTs, so let's just get untyped
|
|
// `SyntaxNode` that contains fields and look for descendant `ast::PathType`s. Of note is that
|
|
// we should not inspect `ast::PathType`s in parameter bounds and where clauses.
|
|
let field_list = match adt {
|
|
ast::Adt::Enum(it) => it.variant_list().map(|list| list.syntax().clone()),
|
|
ast::Adt::Struct(it) => it.field_list().map(|list| list.syntax().clone()),
|
|
ast::Adt::Union(it) => it.record_field_list().map(|list| list.syntax().clone()),
|
|
};
|
|
let associated_types = field_list
|
|
.into_iter()
|
|
.flat_map(|it| it.descendants())
|
|
.filter_map(ast::PathType::cast)
|
|
.filter_map(|p| {
|
|
let name = p.path()?.qualifier()?.as_single_name_ref()?.as_name();
|
|
param_type_set.contains(&name).then_some(p)
|
|
})
|
|
.map(|it| mbe::syntax_node_to_token_tree(it.syntax(), tm, call_site))
|
|
.collect();
|
|
let name_token = name_to_token(tm, name)?;
|
|
Ok(BasicAdtInfo { name: name_token, shape, param_types, associated_types })
|
|
}
|
|
|
|
fn name_to_token(
|
|
token_map: SpanMapRef<'_>,
|
|
name: Option<ast::Name>,
|
|
) -> Result<tt::Ident, ExpandError> {
|
|
let name = name.ok_or_else(|| {
|
|
debug!("parsed item has no name");
|
|
ExpandError::other("missing name")
|
|
})?;
|
|
let span = token_map.span_for_range(name.syntax().text_range());
|
|
let name_token = tt::Ident { span, text: name.text().into() };
|
|
Ok(name_token)
|
|
}
|
|
|
|
/// Given that we are deriving a trait `DerivedTrait` for a type like:
|
|
///
|
|
/// ```ignore (only-for-syntax-highlight)
|
|
/// struct Struct<'a, ..., 'z, A, B: DeclaredTrait, C, ..., Z> where C: WhereTrait {
|
|
/// a: A,
|
|
/// b: B::Item,
|
|
/// b1: <B as DeclaredTrait>::Item,
|
|
/// c1: <C as WhereTrait>::Item,
|
|
/// c2: Option<<C as WhereTrait>::Item>,
|
|
/// ...
|
|
/// }
|
|
/// ```
|
|
///
|
|
/// create an impl like:
|
|
///
|
|
/// ```ignore (only-for-syntax-highlight)
|
|
/// impl<'a, ..., 'z, A, B: DeclaredTrait, C, ... Z> where
|
|
/// C: WhereTrait,
|
|
/// A: DerivedTrait + B1 + ... + BN,
|
|
/// B: DerivedTrait + B1 + ... + BN,
|
|
/// C: DerivedTrait + B1 + ... + BN,
|
|
/// B::Item: DerivedTrait + B1 + ... + BN,
|
|
/// <C as WhereTrait>::Item: DerivedTrait + B1 + ... + BN,
|
|
/// ...
|
|
/// {
|
|
/// ...
|
|
/// }
|
|
/// ```
|
|
///
|
|
/// where B1, ..., BN are the bounds given by `bounds_paths`. Z is a phantom type, and
|
|
/// therefore does not get bound by the derived trait.
|
|
fn expand_simple_derive(
|
|
// FIXME: use
|
|
invoc_span: Span,
|
|
tt: &ast::Adt,
|
|
tm: SpanMapRef<'_>,
|
|
trait_path: tt::Subtree,
|
|
make_trait_body: impl FnOnce(&BasicAdtInfo) -> tt::Subtree,
|
|
) -> ExpandResult<tt::Subtree> {
|
|
let info = match parse_adt(tm, tt, invoc_span) {
|
|
Ok(info) => info,
|
|
Err(e) => {
|
|
return ExpandResult::new(
|
|
tt::Subtree::empty(tt::DelimSpan { open: invoc_span, close: invoc_span }),
|
|
e,
|
|
)
|
|
}
|
|
};
|
|
let trait_body = make_trait_body(&info);
|
|
let mut where_block = vec![];
|
|
let (params, args): (Vec<_>, Vec<_>) = info
|
|
.param_types
|
|
.into_iter()
|
|
.map(|(ident, param_ty, bound)| {
|
|
let ident_ = ident.clone();
|
|
if let Some(b) = bound {
|
|
let ident = ident.clone();
|
|
where_block.push(quote! {invoc_span => #ident : #b , });
|
|
}
|
|
if let Some(ty) = param_ty {
|
|
(quote! {invoc_span => const #ident : #ty , }, quote! {invoc_span => #ident_ , })
|
|
} else {
|
|
let bound = trait_path.clone();
|
|
(quote! {invoc_span => #ident : #bound , }, quote! {invoc_span => #ident_ , })
|
|
}
|
|
})
|
|
.unzip();
|
|
|
|
where_block.extend(info.associated_types.iter().map(|it| {
|
|
let it = it.clone();
|
|
let bound = trait_path.clone();
|
|
quote! {invoc_span => #it : #bound , }
|
|
}));
|
|
|
|
let name = info.name;
|
|
let expanded = quote! {invoc_span =>
|
|
impl < ##params > #trait_path for #name < ##args > where ##where_block { #trait_body }
|
|
};
|
|
ExpandResult::ok(expanded)
|
|
}
|
|
|
|
fn copy_expand(span: Span, tt: &ast::Adt, tm: SpanMapRef<'_>) -> ExpandResult<tt::Subtree> {
|
|
let krate = dollar_crate(span);
|
|
expand_simple_derive(span, tt, tm, quote! {span => #krate::marker::Copy }, |_| quote! {span =>})
|
|
}
|
|
|
|
fn clone_expand(span: Span, tt: &ast::Adt, tm: SpanMapRef<'_>) -> ExpandResult<tt::Subtree> {
|
|
let krate = dollar_crate(span);
|
|
expand_simple_derive(span, tt, tm, quote! {span => #krate::clone::Clone }, |adt| {
|
|
if matches!(adt.shape, AdtShape::Union) {
|
|
let star = tt::Punct { char: '*', spacing: ::tt::Spacing::Alone, span };
|
|
return quote! {span =>
|
|
fn clone(&self) -> Self {
|
|
#star self
|
|
}
|
|
};
|
|
}
|
|
if matches!(&adt.shape, AdtShape::Enum { variants, .. } if variants.is_empty()) {
|
|
let star = tt::Punct { char: '*', spacing: ::tt::Spacing::Alone, span };
|
|
return quote! {span =>
|
|
fn clone(&self) -> Self {
|
|
match #star self {}
|
|
}
|
|
};
|
|
}
|
|
let name = &adt.name;
|
|
let patterns = adt.shape.as_pattern(span, name);
|
|
let exprs = adt.shape.as_pattern_map(name, |it| quote! {span => #it .clone() }, span);
|
|
let arms = patterns.into_iter().zip(exprs.into_iter()).map(|(pat, expr)| {
|
|
let fat_arrow = fat_arrow(span);
|
|
quote! {span =>
|
|
#pat #fat_arrow #expr,
|
|
}
|
|
});
|
|
|
|
quote! {span =>
|
|
fn clone(&self) -> Self {
|
|
match self {
|
|
##arms
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
/// This function exists since `quote! {span => => }` doesn't work.
|
|
fn fat_arrow(span: Span) -> tt::Subtree {
|
|
let eq = tt::Punct { char: '=', spacing: ::tt::Spacing::Joint, span };
|
|
quote! {span => #eq> }
|
|
}
|
|
|
|
/// This function exists since `quote! {span => && }` doesn't work.
|
|
fn and_and(span: Span) -> tt::Subtree {
|
|
let and = tt::Punct { char: '&', spacing: ::tt::Spacing::Joint, span };
|
|
quote! {span => #and& }
|
|
}
|
|
|
|
fn default_expand(span: Span, tt: &ast::Adt, tm: SpanMapRef<'_>) -> ExpandResult<tt::Subtree> {
|
|
let krate = &dollar_crate(span);
|
|
expand_simple_derive(span, tt, tm, quote! {span => #krate::default::Default }, |adt| {
|
|
let body = match &adt.shape {
|
|
AdtShape::Struct(fields) => {
|
|
let name = &adt.name;
|
|
fields.as_pattern_map(
|
|
quote!(span =>#name),
|
|
span,
|
|
|_| quote!(span =>#krate::default::Default::default()),
|
|
)
|
|
}
|
|
AdtShape::Enum { default_variant, variants } => {
|
|
if let Some(d) = default_variant {
|
|
let (name, fields) = &variants[*d];
|
|
let adt_name = &adt.name;
|
|
fields.as_pattern_map(
|
|
quote!(span =>#adt_name :: #name),
|
|
span,
|
|
|_| quote!(span =>#krate::default::Default::default()),
|
|
)
|
|
} else {
|
|
// FIXME: Return expand error here
|
|
quote!(span =>)
|
|
}
|
|
}
|
|
AdtShape::Union => {
|
|
// FIXME: Return expand error here
|
|
quote!(span =>)
|
|
}
|
|
};
|
|
quote! {span =>
|
|
fn default() -> Self {
|
|
#body
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn debug_expand(span: Span, tt: &ast::Adt, tm: SpanMapRef<'_>) -> ExpandResult<tt::Subtree> {
|
|
let krate = &dollar_crate(span);
|
|
expand_simple_derive(span, tt, tm, quote! {span => #krate::fmt::Debug }, |adt| {
|
|
let for_variant = |name: String, v: &VariantShape| match v {
|
|
VariantShape::Struct(fields) => {
|
|
let for_fields = fields.iter().map(|it| {
|
|
let x_string = it.to_string();
|
|
quote! {span =>
|
|
.field(#x_string, & #it)
|
|
}
|
|
});
|
|
quote! {span =>
|
|
f.debug_struct(#name) ##for_fields .finish()
|
|
}
|
|
}
|
|
VariantShape::Tuple(n) => {
|
|
let for_fields = tuple_field_iterator(span, *n).map(|it| {
|
|
quote! {span =>
|
|
.field( & #it)
|
|
}
|
|
});
|
|
quote! {span =>
|
|
f.debug_tuple(#name) ##for_fields .finish()
|
|
}
|
|
}
|
|
VariantShape::Unit => quote! {span =>
|
|
f.write_str(#name)
|
|
},
|
|
};
|
|
if matches!(&adt.shape, AdtShape::Enum { variants, .. } if variants.is_empty()) {
|
|
let star = tt::Punct { char: '*', spacing: ::tt::Spacing::Alone, span };
|
|
return quote! {span =>
|
|
fn fmt(&self, f: &mut #krate::fmt::Formatter) -> #krate::fmt::Result {
|
|
match #star self {}
|
|
}
|
|
};
|
|
}
|
|
let arms = match &adt.shape {
|
|
AdtShape::Struct(fields) => {
|
|
let fat_arrow = fat_arrow(span);
|
|
let name = &adt.name;
|
|
let pat = fields.as_pattern(quote!(span =>#name), span);
|
|
let expr = for_variant(name.to_string(), fields);
|
|
vec![quote! {span => #pat #fat_arrow #expr }]
|
|
}
|
|
AdtShape::Enum { variants, .. } => variants
|
|
.iter()
|
|
.map(|(name, v)| {
|
|
let fat_arrow = fat_arrow(span);
|
|
let adt_name = &adt.name;
|
|
let pat = v.as_pattern(quote!(span =>#adt_name :: #name), span);
|
|
let expr = for_variant(name.to_string(), v);
|
|
quote! {span =>
|
|
#pat #fat_arrow #expr ,
|
|
}
|
|
})
|
|
.collect(),
|
|
AdtShape::Union => {
|
|
// FIXME: Return expand error here
|
|
vec![]
|
|
}
|
|
};
|
|
quote! {span =>
|
|
fn fmt(&self, f: &mut #krate::fmt::Formatter) -> #krate::fmt::Result {
|
|
match self {
|
|
##arms
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn hash_expand(span: Span, tt: &ast::Adt, tm: SpanMapRef<'_>) -> ExpandResult<tt::Subtree> {
|
|
let krate = &dollar_crate(span);
|
|
expand_simple_derive(span, tt, tm, quote! {span => #krate::hash::Hash }, |adt| {
|
|
if matches!(adt.shape, AdtShape::Union) {
|
|
// FIXME: Return expand error here
|
|
return quote! {span =>};
|
|
}
|
|
if matches!(&adt.shape, AdtShape::Enum { variants, .. } if variants.is_empty()) {
|
|
let star = tt::Punct { char: '*', spacing: ::tt::Spacing::Alone, span };
|
|
return quote! {span =>
|
|
fn hash<H: #krate::hash::Hasher>(&self, ra_expand_state: &mut H) {
|
|
match #star self {}
|
|
}
|
|
};
|
|
}
|
|
let arms =
|
|
adt.shape.as_pattern(span, &adt.name).into_iter().zip(adt.shape.field_names(span)).map(
|
|
|(pat, names)| {
|
|
let expr = {
|
|
let it =
|
|
names.iter().map(|it| quote! {span => #it . hash(ra_expand_state); });
|
|
quote! {span => {
|
|
##it
|
|
} }
|
|
};
|
|
let fat_arrow = fat_arrow(span);
|
|
quote! {span =>
|
|
#pat #fat_arrow #expr ,
|
|
}
|
|
},
|
|
);
|
|
let check_discriminant = if matches!(&adt.shape, AdtShape::Enum { .. }) {
|
|
quote! {span => #krate::mem::discriminant(self).hash(ra_expand_state); }
|
|
} else {
|
|
quote! {span =>}
|
|
};
|
|
quote! {span =>
|
|
fn hash<H: #krate::hash::Hasher>(&self, ra_expand_state: &mut H) {
|
|
#check_discriminant
|
|
match self {
|
|
##arms
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn eq_expand(span: Span, tt: &ast::Adt, tm: SpanMapRef<'_>) -> ExpandResult<tt::Subtree> {
|
|
let krate = dollar_crate(span);
|
|
expand_simple_derive(span, tt, tm, quote! {span => #krate::cmp::Eq }, |_| quote! {span =>})
|
|
}
|
|
|
|
fn partial_eq_expand(span: Span, tt: &ast::Adt, tm: SpanMapRef<'_>) -> ExpandResult<tt::Subtree> {
|
|
let krate = dollar_crate(span);
|
|
expand_simple_derive(span, tt, tm, quote! {span => #krate::cmp::PartialEq }, |adt| {
|
|
if matches!(adt.shape, AdtShape::Union) {
|
|
// FIXME: Return expand error here
|
|
return quote! {span =>};
|
|
}
|
|
let name = &adt.name;
|
|
|
|
let (self_patterns, other_patterns) = self_and_other_patterns(adt, name, span);
|
|
let arms = izip!(self_patterns, other_patterns, adt.shape.field_names(span)).map(
|
|
|(pat1, pat2, names)| {
|
|
let fat_arrow = fat_arrow(span);
|
|
let body = match &*names {
|
|
[] => {
|
|
quote!(span =>true)
|
|
}
|
|
[first, rest @ ..] => {
|
|
let rest = rest.iter().map(|it| {
|
|
let t1 = tt::Ident::new(format!("{}_self", it.text), it.span);
|
|
let t2 = tt::Ident::new(format!("{}_other", it.text), it.span);
|
|
let and_and = and_and(span);
|
|
quote!(span =>#and_and #t1 .eq( #t2 ))
|
|
});
|
|
let first = {
|
|
let t1 = tt::Ident::new(format!("{}_self", first.text), first.span);
|
|
let t2 = tt::Ident::new(format!("{}_other", first.text), first.span);
|
|
quote!(span =>#t1 .eq( #t2 ))
|
|
};
|
|
quote!(span =>#first ##rest)
|
|
}
|
|
};
|
|
quote! {span => ( #pat1 , #pat2 ) #fat_arrow #body , }
|
|
},
|
|
);
|
|
|
|
let fat_arrow = fat_arrow(span);
|
|
quote! {span =>
|
|
fn eq(&self, other: &Self) -> bool {
|
|
match (self, other) {
|
|
##arms
|
|
_unused #fat_arrow false
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn self_and_other_patterns(
|
|
adt: &BasicAdtInfo,
|
|
name: &tt::Ident,
|
|
span: Span,
|
|
) -> (Vec<tt::Subtree>, Vec<tt::Subtree>) {
|
|
let self_patterns = adt.shape.as_pattern_map(
|
|
name,
|
|
|it| {
|
|
let t = tt::Ident::new(format!("{}_self", it.text), it.span);
|
|
quote!(span =>#t)
|
|
},
|
|
span,
|
|
);
|
|
let other_patterns = adt.shape.as_pattern_map(
|
|
name,
|
|
|it| {
|
|
let t = tt::Ident::new(format!("{}_other", it.text), it.span);
|
|
quote!(span =>#t)
|
|
},
|
|
span,
|
|
);
|
|
(self_patterns, other_patterns)
|
|
}
|
|
|
|
fn ord_expand(span: Span, tt: &ast::Adt, tm: SpanMapRef<'_>) -> ExpandResult<tt::Subtree> {
|
|
let krate = &dollar_crate(span);
|
|
expand_simple_derive(span, tt, tm, quote! {span => #krate::cmp::Ord }, |adt| {
|
|
fn compare(
|
|
krate: &tt::Ident,
|
|
left: tt::Subtree,
|
|
right: tt::Subtree,
|
|
rest: tt::Subtree,
|
|
span: Span,
|
|
) -> tt::Subtree {
|
|
let fat_arrow1 = fat_arrow(span);
|
|
let fat_arrow2 = fat_arrow(span);
|
|
quote! {span =>
|
|
match #left.cmp(&#right) {
|
|
#krate::cmp::Ordering::Equal #fat_arrow1 {
|
|
#rest
|
|
}
|
|
c #fat_arrow2 return c,
|
|
}
|
|
}
|
|
}
|
|
if matches!(adt.shape, AdtShape::Union) {
|
|
// FIXME: Return expand error here
|
|
return quote!(span =>);
|
|
}
|
|
let (self_patterns, other_patterns) = self_and_other_patterns(adt, &adt.name, span);
|
|
let arms = izip!(self_patterns, other_patterns, adt.shape.field_names(span)).map(
|
|
|(pat1, pat2, fields)| {
|
|
let mut body = quote!(span =>#krate::cmp::Ordering::Equal);
|
|
for f in fields.into_iter().rev() {
|
|
let t1 = tt::Ident::new(format!("{}_self", f.text), f.span);
|
|
let t2 = tt::Ident::new(format!("{}_other", f.text), f.span);
|
|
body = compare(krate, quote!(span =>#t1), quote!(span =>#t2), body, span);
|
|
}
|
|
let fat_arrow = fat_arrow(span);
|
|
quote! {span => ( #pat1 , #pat2 ) #fat_arrow #body , }
|
|
},
|
|
);
|
|
let fat_arrow = fat_arrow(span);
|
|
let mut body = quote! {span =>
|
|
match (self, other) {
|
|
##arms
|
|
_unused #fat_arrow #krate::cmp::Ordering::Equal
|
|
}
|
|
};
|
|
if matches!(&adt.shape, AdtShape::Enum { .. }) {
|
|
let left = quote!(span =>#krate::intrinsics::discriminant_value(self));
|
|
let right = quote!(span =>#krate::intrinsics::discriminant_value(other));
|
|
body = compare(krate, left, right, body, span);
|
|
}
|
|
quote! {span =>
|
|
fn cmp(&self, other: &Self) -> #krate::cmp::Ordering {
|
|
#body
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
fn partial_ord_expand(span: Span, tt: &ast::Adt, tm: SpanMapRef<'_>) -> ExpandResult<tt::Subtree> {
|
|
let krate = &dollar_crate(span);
|
|
expand_simple_derive(span, tt, tm, quote! {span => #krate::cmp::PartialOrd }, |adt| {
|
|
fn compare(
|
|
krate: &tt::Ident,
|
|
left: tt::Subtree,
|
|
right: tt::Subtree,
|
|
rest: tt::Subtree,
|
|
span: Span,
|
|
) -> tt::Subtree {
|
|
let fat_arrow1 = fat_arrow(span);
|
|
let fat_arrow2 = fat_arrow(span);
|
|
quote! {span =>
|
|
match #left.partial_cmp(&#right) {
|
|
#krate::option::Option::Some(#krate::cmp::Ordering::Equal) #fat_arrow1 {
|
|
#rest
|
|
}
|
|
c #fat_arrow2 return c,
|
|
}
|
|
}
|
|
}
|
|
if matches!(adt.shape, AdtShape::Union) {
|
|
// FIXME: Return expand error here
|
|
return quote!(span =>);
|
|
}
|
|
let left = quote!(span =>#krate::intrinsics::discriminant_value(self));
|
|
let right = quote!(span =>#krate::intrinsics::discriminant_value(other));
|
|
|
|
let (self_patterns, other_patterns) = self_and_other_patterns(adt, &adt.name, span);
|
|
let arms = izip!(self_patterns, other_patterns, adt.shape.field_names(span)).map(
|
|
|(pat1, pat2, fields)| {
|
|
let mut body =
|
|
quote!(span =>#krate::option::Option::Some(#krate::cmp::Ordering::Equal));
|
|
for f in fields.into_iter().rev() {
|
|
let t1 = tt::Ident::new(format!("{}_self", f.text), f.span);
|
|
let t2 = tt::Ident::new(format!("{}_other", f.text), f.span);
|
|
body = compare(krate, quote!(span =>#t1), quote!(span =>#t2), body, span);
|
|
}
|
|
let fat_arrow = fat_arrow(span);
|
|
quote! {span => ( #pat1 , #pat2 ) #fat_arrow #body , }
|
|
},
|
|
);
|
|
let fat_arrow = fat_arrow(span);
|
|
let body = compare(
|
|
krate,
|
|
left,
|
|
right,
|
|
quote! {span =>
|
|
match (self, other) {
|
|
##arms
|
|
_unused #fat_arrow #krate::option::Option::Some(#krate::cmp::Ordering::Equal)
|
|
}
|
|
},
|
|
span,
|
|
);
|
|
quote! {span =>
|
|
fn partial_cmp(&self, other: &Self) -> #krate::option::Option::Option<#krate::cmp::Ordering> {
|
|
#body
|
|
}
|
|
}
|
|
})
|
|
}
|