1 //! The compiler code necessary to implement the `#[derive]` extensions.
5 use rustc_ast::{GenericArg, Impl, ItemKind, MetaItem};
6 use rustc_expand::base::{Annotatable, ExpandResult, ExtCtxt, MultiItemModifier};
7 use rustc_span::symbol::{sym, Ident, Symbol};
10 macro path_local($x:ident) {
11 generic::ty::Path::new_local(sym::$x)
14 macro pathvec_std($($rest:ident)::+) {{
15 vec![ $( sym::$rest ),+ ]
18 macro path_std($($x:tt)*) {
19 generic::ty::Path::new( pathvec_std!( $($x)* ) )
32 #[path = "cmp/ord.rs"]
34 #[path = "cmp/partial_eq.rs"]
36 #[path = "cmp/partial_ord.rs"]
41 pub(crate) type BuiltinDeriveFn =
42 fn(&mut ExtCtxt<'_>, Span, &MetaItem, &Annotatable, &mut dyn FnMut(Annotatable), bool);
44 pub(crate) struct BuiltinDerive(pub(crate) BuiltinDeriveFn);
46 impl MultiItemModifier for BuiltinDerive {
49 ecx: &mut ExtCtxt<'_>,
53 is_derive_const: bool,
54 ) -> ExpandResult<Vec<Annotatable>, Annotatable> {
55 // FIXME: Built-in derives often forget to give spans contexts,
56 // so we are doing it here in a centralized way.
57 let span = ecx.with_def_site_ctxt(span);
58 let mut items = Vec::new();
60 Annotatable::Stmt(stmt) => {
61 if let ast::StmtKind::Item(item) = stmt.into_inner().kind {
66 &Annotatable::Item(item),
68 // Cannot use 'ecx.stmt_item' here, because we need to pass 'ecx'
70 items.push(Annotatable::Stmt(P(ast::Stmt {
71 id: ast::DUMMY_NODE_ID,
72 kind: ast::StmtKind::Item(a.expect_item()),
79 unreachable!("should have already errored on non-item statement")
83 (self.0)(ecx, span, meta_item, &item, &mut |a| items.push(a), is_derive_const);
86 ExpandResult::Ready(items)
90 /// Constructs an expression that calls an intrinsic
95 args: Vec<P<ast::Expr>>,
97 let span = cx.with_def_site_ctxt(span);
98 let path = cx.std_path(&[sym::intrinsics, intrinsic]);
99 cx.expr_call_global(span, path, args)
102 /// Constructs an expression that calls the `unreachable` intrinsic.
103 fn call_unreachable(cx: &ExtCtxt<'_>, span: Span) -> P<ast::Expr> {
104 let span = cx.with_def_site_ctxt(span);
105 let path = cx.std_path(&[sym::intrinsics, sym::unreachable]);
106 let call = cx.expr_call_global(span, path, vec![]);
108 cx.expr_block(P(ast::Block {
109 stmts: vec![cx.stmt_expr(call)],
110 id: ast::DUMMY_NODE_ID,
111 rules: ast::BlockCheckMode::Unsafe(ast::CompilerGenerated),
114 could_be_bare_literal: false,
118 // Injects `impl<...> Structural for ItemType<...> { }`. In particular,
119 // does *not* add `where T: Structural` for parameters `T` in `...`.
120 // (That's the main reason we cannot use TraitDef here.)
121 fn inject_impl_of_structural_trait(
122 cx: &mut ExtCtxt<'_>,
125 structural_path: generic::ty::Path,
126 push: &mut dyn FnMut(Annotatable),
128 let Annotatable::Item(ref item) = *item else {
132 let generics = match item.kind {
133 ItemKind::Struct(_, ref generics) | ItemKind::Enum(_, ref generics) => generics,
134 // Do not inject `impl Structural for Union`. (`PartialEq` does not
135 // support unions, so we will see error downstream.)
136 ItemKind::Union(..) => return,
140 // Create generics param list for where clauses and impl headers
141 let mut generics = generics.clone();
143 let ctxt = span.ctxt();
145 // Create the type of `self`.
147 // in addition, remove defaults from generic params (impls cannot have them).
148 let self_params: Vec<_> = generics
151 .map(|param| match &mut param.kind {
152 ast::GenericParamKind::Lifetime => ast::GenericArg::Lifetime(
153 cx.lifetime(param.ident.span.with_ctxt(ctxt), param.ident),
155 ast::GenericParamKind::Type { default } => {
157 ast::GenericArg::Type(cx.ty_ident(param.ident.span.with_ctxt(ctxt), param.ident))
159 ast::GenericParamKind::Const { ty: _, kw_span: _, default } => {
161 ast::GenericArg::Const(
162 cx.const_ident(param.ident.span.with_ctxt(ctxt), param.ident),
168 let type_ident = item.ident;
170 let trait_ref = cx.trait_ref(structural_path.to_path(cx, span, type_ident, &generics));
171 let self_type = cx.ty_path(cx.path_all(span, false, vec![type_ident], self_params));
173 // It would be nice to also encode constraint `where Self: Eq` (by adding it
174 // onto `generics` cloned above). Unfortunately, that strategy runs afoul of
175 // rust-lang/rust#48214. So we perform that additional check in the compiler
176 // itself, instead of encoding it here.
178 // Keep the lint and stability attributes of the original item, to control
179 // how the generated implementation is linted.
180 let mut attrs = ast::AttrVec::new();
185 [sym::allow, sym::warn, sym::deny, sym::forbid, sym::stable, sym::unstable]
186 .contains(&a.name_or_empty())
190 // Mark as `automatically_derived` to avoid some silly lints.
191 attrs.push(cx.attribute(cx.meta_word(span, sym::automatically_derived)));
193 let newitem = cx.item(
197 ItemKind::Impl(Box::new(Impl {
198 unsafety: ast::Unsafe::No,
199 polarity: ast::ImplPolarity::Positive,
200 defaultness: ast::Defaultness::Final,
201 constness: ast::Const::No,
203 of_trait: Some(trait_ref),
209 push(Annotatable::Item(newitem));
213 cx: &mut ExtCtxt<'_>,
214 stmts: &mut Vec<ast::Stmt>,
217 assert_path: &[Symbol],
219 // Generate statement `let _: assert_path<ty>;`.
220 let span = cx.with_def_site_ctxt(span);
221 let assert_path = cx.path_all(span, true, cx.std_path(assert_path), vec![GenericArg::Type(ty)]);
222 stmts.push(cx.stmt_let_type_only(span, cx.ty_path(assert_path)));