compiler/rustc_builtin_macros/src/deriving/debug.rs

   1 use crate::deriving::generic::ty::*;
   2 use crate::deriving::generic::*;
   3 use crate::deriving::path_std;
   4
   5 use rustc_ast::ptr::P;
   6 use rustc_ast::{self as ast, Expr, LocalKind, MetaItem};
   7 use rustc_expand::base::{Annotatable, ExtCtxt};
   8 use rustc_span::symbol::{sym, Ident};
   9 use rustc_span::{Span, DUMMY_SP};
  10
  11 fn make_mut_borrow(cx: &mut ExtCtxt<'_>, sp: Span, expr: P<Expr>) -> P<Expr> {
  12     cx.expr(sp, ast::ExprKind::AddrOf(ast::BorrowKind::Ref, ast::Mutability::Mut, expr))
  13 }
  14
  15 pub fn expand_deriving_debug(
  16     cx: &mut ExtCtxt<'_>,
  17     span: Span,
  18     mitem: &MetaItem,
  19     item: &Annotatable,
  20     push: &mut dyn FnMut(Annotatable),
  21 ) {
  22     // &mut ::std::fmt::Formatter
  23     let fmtr =
  24         Ptr(Box::new(Literal(path_std!(fmt::Formatter))), Borrowed(None, ast::Mutability::Mut));
  25
  26     let trait_def = TraitDef {
  27         span,
  28         attributes: Vec::new(),
  29         path: path_std!(fmt::Debug),
  30         additional_bounds: Vec::new(),
  31         generics: Bounds::empty(),
  32         is_unsafe: false,
  33         supports_unions: false,
  34         methods: vec![MethodDef {
  35             name: sym::fmt,
  36             generics: Bounds::empty(),
  37             explicit_self: borrowed_explicit_self(),
  38             args: vec![(fmtr, sym::f)],
  39             ret_ty: Literal(path_std!(fmt::Result)),
  40             attributes: Vec::new(),
  41             is_unsafe: false,
  42             unify_fieldless_variants: false,
  43             combine_substructure: combine_substructure(Box::new(|a, b, c| {
  44                 show_substructure(a, b, c)
  45             })),
  46         }],
  47         associated_types: Vec::new(),
  48     };
  49     trait_def.expand(cx, mitem, item, push)
  50 }
  51
  52 /// We use the debug builders to do the heavy lifting here
  53 fn show_substructure(cx: &mut ExtCtxt<'_>, span: Span, substr: &Substructure<'_>) -> P<Expr> {
  54     // build fmt.debug_struct(<name>).field(<fieldname>, &<fieldval>)....build()
  55     // or fmt.debug_tuple(<name>).field(&<fieldval>)....build()
  56     // based on the "shape".
  57     let (ident, vdata, fields) = match substr.fields {
  58         Struct(vdata, fields) => (substr.type_ident, *vdata, fields),
  59         EnumMatching(_, _, v, fields) => (v.ident, &v.data, fields),
  60         EnumNonMatchingCollapsed(..) | StaticStruct(..) | StaticEnum(..) => {
  61             cx.span_bug(span, "nonsensical .fields in `#[derive(Debug)]`")
  62         }
  63     };
  64
  65     // We want to make sure we have the ctxt set so that we can use unstable methods
  66     let span = cx.with_def_site_ctxt(span);
  67     let name = cx.expr_lit(span, ast::LitKind::Str(ident.name, ast::StrStyle::Cooked));
  68     let builder = Ident::new(sym::debug_trait_builder, span);
  69     let builder_expr = cx.expr_ident(span, builder);
  70
  71     let fmt = substr.nonself_args[0].clone();
  72
  73     let mut stmts = Vec::with_capacity(fields.len() + 2);
  74     let fn_path_finish;
  75     match vdata {
  76         ast::VariantData::Tuple(..) | ast::VariantData::Unit(..) => {
  77             // tuple struct/"normal" variant
  78             let fn_path_debug_tuple = cx.std_path(&[sym::fmt, sym::Formatter, sym::debug_tuple]);
  79             let expr = cx.expr_call_global(span, fn_path_debug_tuple, vec![fmt, name]);
  80             let expr = make_mut_borrow(cx, span, expr);
  81             stmts.push(cx.stmt_let(span, false, builder, expr));
  82
  83             for field in fields {
  84                 // Use double indirection to make sure this works for unsized types
  85                 let field = cx.expr_addr_of(field.span, field.self_.clone());
  86                 let field = cx.expr_addr_of(field.span, field);
  87
  88                 let fn_path_field = cx.std_path(&[sym::fmt, sym::DebugTuple, sym::field]);
  89                 let expr =
  90                     cx.expr_call_global(span, fn_path_field, vec![builder_expr.clone(), field]);
  91
  92                 // Use `let _ = expr;` to avoid triggering the
  93                 // unused_results lint.
  94                 stmts.push(stmt_let_underscore(cx, span, expr));
  95             }
  96
  97             fn_path_finish = cx.std_path(&[sym::fmt, sym::DebugTuple, sym::finish]);
  98         }
  99         ast::VariantData::Struct(..) => {
 100             // normal struct/struct variant
 101             let fn_path_debug_struct = cx.std_path(&[sym::fmt, sym::Formatter, sym::debug_struct]);
 102             let expr = cx.expr_call_global(span, fn_path_debug_struct, vec![fmt, name]);
 103             let expr = make_mut_borrow(cx, span, expr);
 104             stmts.push(cx.stmt_let(DUMMY_SP, false, builder, expr));
 105
 106             for field in fields {
 107                 let name = cx.expr_lit(
 108                     field.span,
 109                     ast::LitKind::Str(field.name.unwrap().name, ast::StrStyle::Cooked),
 110                 );
 111
 112                 // Use double indirection to make sure this works for unsized types
 113                 let fn_path_field = cx.std_path(&[sym::fmt, sym::DebugStruct, sym::field]);
 114                 let field = cx.expr_addr_of(field.span, field.self_.clone());
 115                 let field = cx.expr_addr_of(field.span, field);
 116                 let expr = cx.expr_call_global(
 117                     span,
 118                     fn_path_field,
 119                     vec![builder_expr.clone(), name, field],
 120                 );
 121                 stmts.push(stmt_let_underscore(cx, span, expr));
 122             }
 123             fn_path_finish = cx.std_path(&[sym::fmt, sym::DebugStruct, sym::finish]);
 124         }
 125     }
 126
 127     let expr = cx.expr_call_global(span, fn_path_finish, vec![builder_expr]);
 128
 129     stmts.push(cx.stmt_expr(expr));
 130     let block = cx.block(span, stmts);
 131     cx.expr_block(block)
 132 }
 133
 134 fn stmt_let_underscore(cx: &mut ExtCtxt<'_>, sp: Span, expr: P<ast::Expr>) -> ast::Stmt {
 135     let local = P(ast::Local {
 136         pat: cx.pat_wild(sp),
 137         ty: None,
 138         id: ast::DUMMY_NODE_ID,
 139         kind: LocalKind::Init(expr),
 140         span: sp,
 141         attrs: ast::AttrVec::new(),
 142         tokens: None,
 143     });
 144     ast::Stmt { id: ast::DUMMY_NODE_ID, kind: ast::StmtKind::Local(local), span: sp }
 145 }