|
| 1 | +use ast::HasAttrs; |
| 2 | +use rustc_ast::{ |
| 3 | + self as ast, GenericArg, GenericBound, GenericParamKind, ItemKind, MetaItem, |
| 4 | + TraitBoundModifiers, |
| 5 | +}; |
| 6 | +use rustc_expand::base::{Annotatable, ExtCtxt}; |
| 7 | +use rustc_span::symbol::{sym, Ident}; |
| 8 | +use rustc_span::Span; |
| 9 | +use smallvec::{smallvec, SmallVec}; |
| 10 | +use thin_vec::{thin_vec, ThinVec}; |
| 11 | + |
| 12 | +macro_rules! path { |
| 13 | + ($span:expr, $($part:ident)::*) => { vec![$(Ident::new(sym::$part, $span),)*] } |
| 14 | +} |
| 15 | + |
| 16 | +pub fn expand_deriving_smart_ptr( |
| 17 | + cx: &ExtCtxt<'_>, |
| 18 | + span: Span, |
| 19 | + _mitem: &MetaItem, |
| 20 | + item: &Annotatable, |
| 21 | + push: &mut dyn FnMut(Annotatable), |
| 22 | + _is_const: bool, |
| 23 | +) { |
| 24 | + let (name_ident, generics) = if let Annotatable::Item(aitem) = item |
| 25 | + && let ItemKind::Struct(_, g) = &aitem.kind |
| 26 | + { |
| 27 | + (aitem.ident, g) |
| 28 | + } else { |
| 29 | + cx.dcx().struct_span_err(span, "`SmartPointer` can only be derived on `struct`s").emit(); |
| 30 | + return; |
| 31 | + }; |
| 32 | + |
| 33 | + // Convert generic parameters (from the struct) into generic args. |
| 34 | + let mut pointee_param = None; |
| 35 | + let mut multiple_pointee_diag: SmallVec<[_; 2]> = smallvec![]; |
| 36 | + let self_params = generics |
| 37 | + .params |
| 38 | + .iter() |
| 39 | + .enumerate() |
| 40 | + .map(|(idx, p)| match p.kind { |
| 41 | + GenericParamKind::Lifetime => GenericArg::Lifetime(cx.lifetime(p.span(), p.ident)), |
| 42 | + GenericParamKind::Type { .. } => { |
| 43 | + if p.attrs().iter().any(|attr| attr.has_name(sym::pointee)) { |
| 44 | + if pointee_param.is_some() { |
| 45 | + multiple_pointee_diag.push(cx.dcx().struct_span_err( |
| 46 | + p.span(), |
| 47 | + "`SmartPointer` can only admit one type as pointee", |
| 48 | + )); |
| 49 | + } else { |
| 50 | + pointee_param = Some(idx); |
| 51 | + } |
| 52 | + } |
| 53 | + GenericArg::Type(cx.ty_ident(p.span(), p.ident)) |
| 54 | + } |
| 55 | + GenericParamKind::Const { .. } => GenericArg::Const(cx.const_ident(p.span(), p.ident)), |
| 56 | + }) |
| 57 | + .collect::<Vec<_>>(); |
| 58 | + let Some(pointee_param_idx) = pointee_param else { |
| 59 | + cx.dcx().struct_span_err( |
| 60 | + span, |
| 61 | + "At least one generic type should be designated as `#[pointee]` in order to derive `SmartPointer` traits", |
| 62 | + ).emit(); |
| 63 | + return; |
| 64 | + }; |
| 65 | + if !multiple_pointee_diag.is_empty() { |
| 66 | + for diag in multiple_pointee_diag { |
| 67 | + diag.emit(); |
| 68 | + } |
| 69 | + return; |
| 70 | + } |
| 71 | + |
| 72 | + // Create the type of `self`. |
| 73 | + let path = cx.path_all(span, false, vec![name_ident], self_params.clone()); |
| 74 | + let self_type = cx.ty_path(path); |
| 75 | + |
| 76 | + // Declare helper function that adds implementation blocks. |
| 77 | + // FIXME: Copy attrs from struct? |
| 78 | + let attrs = thin_vec![cx.attr_word(sym::automatically_derived, span),]; |
| 79 | + let mut add_impl_block = |generics, trait_symbol, trait_args| { |
| 80 | + let mut parts = path!(span, core::ops); |
| 81 | + parts.push(Ident::new(trait_symbol, span)); |
| 82 | + let trait_path = cx.path_all(span, true, parts, trait_args); |
| 83 | + let trait_ref = cx.trait_ref(trait_path); |
| 84 | + let item = cx.item( |
| 85 | + span, |
| 86 | + Ident::empty(), |
| 87 | + attrs.clone(), |
| 88 | + ast::ItemKind::Impl(Box::new(ast::Impl { |
| 89 | + safety: ast::Safety::Default, |
| 90 | + polarity: ast::ImplPolarity::Positive, |
| 91 | + defaultness: ast::Defaultness::Final, |
| 92 | + constness: ast::Const::No, |
| 93 | + generics, |
| 94 | + of_trait: Some(trait_ref), |
| 95 | + self_ty: self_type.clone(), |
| 96 | + items: ThinVec::new(), |
| 97 | + })), |
| 98 | + ); |
| 99 | + push(Annotatable::Item(item)); |
| 100 | + }; |
| 101 | + |
| 102 | + // Create unsized `self`, that is, one where the first type arg is replace with `__S`. For |
| 103 | + // example, instead of `MyType<'a, T>`, it will be `MyType<'a, __S>`. |
| 104 | + let s_ty = cx.ty_ident(span, Ident::new(sym::__S, span)); |
| 105 | + let mut alt_self_params = self_params; |
| 106 | + alt_self_params[pointee_param_idx] = GenericArg::Type(s_ty.clone()); |
| 107 | + let alt_self_type = cx.ty_path(cx.path_all(span, false, vec![name_ident], alt_self_params)); |
| 108 | + |
| 109 | + // Find the first type parameter and add an `Unsize<__S>` bound to it. |
| 110 | + let mut impl_generics = generics.clone(); |
| 111 | + { |
| 112 | + let p = &mut impl_generics.params[pointee_param_idx]; |
| 113 | + let arg = GenericArg::Type(s_ty.clone()); |
| 114 | + let unsize = cx.path_all(span, true, path!(span, core::marker::Unsize), vec![arg]); |
| 115 | + p.bounds.push(cx.trait_bound(unsize, false)); |
| 116 | + } |
| 117 | + |
| 118 | + // Add the `__S: ?Sized` extra parameter to the impl block. |
| 119 | + let sized = cx.path_global(span, path!(span, core::marker::Sized)); |
| 120 | + let bound = GenericBound::Trait( |
| 121 | + cx.poly_trait_ref(span, sized), |
| 122 | + TraitBoundModifiers { |
| 123 | + polarity: ast::BoundPolarity::Maybe(span), |
| 124 | + constness: ast::BoundConstness::Never, |
| 125 | + asyncness: ast::BoundAsyncness::Normal, |
| 126 | + }, |
| 127 | + ); |
| 128 | + let extra_param = cx.typaram(span, Ident::new(sym::__S, span), vec![bound], None); |
| 129 | + impl_generics.params.push(extra_param); |
| 130 | + |
| 131 | + // Add the impl blocks for `DispatchFromDyn` and `CoerceUnsized`. |
| 132 | + let gen_args = vec![GenericArg::Type(alt_self_type.clone())]; |
| 133 | + add_impl_block(impl_generics.clone(), sym::DispatchFromDyn, gen_args.clone()); |
| 134 | + add_impl_block(impl_generics.clone(), sym::CoerceUnsized, gen_args.clone()); |
| 135 | +} |
0 commit comments