From 9652fcbb6e59845904ef246b41231f5df198dd0d Mon Sep 17 00:00:00 2001 From: Srinivas Reddy Thatiparthy Date: Tue, 19 Jul 2016 23:02:06 +0530 Subject: [PATCH] Run rustfmt on libsyntax_ext/deriving folder --- src/libsyntax_ext/deriving/bounds.rs | 8 +- src/libsyntax_ext/deriving/clone.rs | 98 +-- src/libsyntax_ext/deriving/cmp/eq.rs | 67 +- src/libsyntax_ext/deriving/cmp/ord.rs | 144 ++-- src/libsyntax_ext/deriving/cmp/partial_eq.rs | 61 +- src/libsyntax_ext/deriving/cmp/partial_ord.rs | 247 +++--- src/libsyntax_ext/deriving/debug.rs | 89 +-- src/libsyntax_ext/deriving/decodable.rs | 175 +++-- src/libsyntax_ext/deriving/default.rs | 48 +- src/libsyntax_ext/deriving/encodable.rs | 92 +-- src/libsyntax_ext/deriving/generic/mod.rs | 733 +++++++++--------- src/libsyntax_ext/deriving/hash.rs | 55 +- src/libsyntax_ext/deriving/mod.rs | 42 +- 13 files changed, 932 insertions(+), 927 deletions(-) diff --git a/src/libsyntax_ext/deriving/bounds.rs b/src/libsyntax_ext/deriving/bounds.rs index 36818e000b55b..cfc98bf36871f 100644 --- a/src/libsyntax_ext/deriving/bounds.rs +++ b/src/libsyntax_ext/deriving/bounds.rs @@ -12,15 +12,14 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast::MetaItem; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax_pos::Span; pub fn expand_deriving_unsafe_bound(cx: &mut ExtCtxt, span: Span, _: &MetaItem, _: &Annotatable, - _: &mut FnMut(Annotatable)) -{ + _: &mut FnMut(Annotatable)) { cx.span_err(span, "this unsafe trait should be implemented explicitly"); } @@ -28,8 +27,7 @@ pub fn expand_deriving_copy(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { let mut v = cx.crate_root.map(|s| vec![s]).unwrap_or(Vec::new()); v.push("marker"); v.push("Copy"); diff --git a/src/libsyntax_ext/deriving/clone.rs b/src/libsyntax_ext/deriving/clone.rs index 1e47ebb85837a..ce8ce2209d8c4 100644 --- a/src/libsyntax_ext/deriving/clone.rs +++ b/src/libsyntax_ext/deriving/clone.rs @@ -11,23 +11,25 @@ use deriving::generic::*; use deriving::generic::ty::*; -use syntax::ast::{Expr, ItemKind, Generics, MetaItem, VariantData}; +use syntax::ast::{Expr, Generics, ItemKind, MetaItem, VariantData}; use syntax::attr; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; use syntax_pos::Span; #[derive(PartialEq)] -enum Mode { Deep, Shallow } +enum Mode { + Deep, + Shallow, +} pub fn expand_deriving_clone(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { // check if we can use a short form // // the short form is `fn clone(&self) -> Self { *self }` @@ -46,8 +48,8 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt, match annitem.node { ItemKind::Struct(_, Generics { ref ty_params, .. }) | ItemKind::Enum(_, Generics { ref ty_params, .. }) - if ty_params.is_empty() - && attr::contains_name(&annitem.attrs, "derive_Copy") => { + if ty_params.is_empty() && + attr::contains_name(&annitem.attrs, "derive_Copy") => { bounds = vec![Literal(path_std!(cx, core::marker::Copy))]; unify_fieldless_variants = true; @@ -66,11 +68,11 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt, } } - _ => cx.span_bug(span, "#[derive(Clone)] on trait item or impl item") + _ => cx.span_bug(span, "#[derive(Clone)] on trait item or impl item"), } let inline = cx.meta_word(span, InternedString::new("inline")); - let attrs = vec!(cx.attribute(span, inline)); + let attrs = vec![cx.attribute(span, inline)]; let trait_def = TraitDef { span: span, attributes: Vec::new(), @@ -78,42 +80,41 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt, additional_bounds: bounds, generics: LifetimeBounds::empty(), is_unsafe: false, - methods: vec!( - MethodDef { - name: "clone", - generics: LifetimeBounds::empty(), - explicit_self: borrowed_explicit_self(), - args: Vec::new(), - ret_ty: Self_, - attributes: attrs, - is_unsafe: false, - unify_fieldless_variants: unify_fieldless_variants, - combine_substructure: substructure, - } - ), + methods: vec![MethodDef { + name: "clone", + generics: LifetimeBounds::empty(), + explicit_self: borrowed_explicit_self(), + args: Vec::new(), + ret_ty: Self_, + attributes: attrs, + is_unsafe: false, + unify_fieldless_variants: unify_fieldless_variants, + combine_substructure: substructure, + }], associated_types: Vec::new(), }; trait_def.expand(cx, mitem, item, push) } -fn cs_clone( - name: &str, - cx: &mut ExtCtxt, trait_span: Span, - substr: &Substructure, - mode: Mode) -> P { +fn cs_clone(name: &str, + cx: &mut ExtCtxt, + trait_span: Span, + substr: &Substructure, + mode: Mode) + -> P { let ctor_path; let all_fields; let fn_path = match mode { Mode::Shallow => cx.std_path(&["clone", "assert_receiver_is_clone"]), - Mode::Deep => cx.std_path(&["clone", "Clone", "clone"]), + Mode::Deep => cx.std_path(&["clone", "Clone", "clone"]), }; let subcall = |field: &FieldInfo| { let args = vec![cx.expr_addr_of(field.span, field.self_.clone())]; let span = if mode == Mode::Shallow { // set the expn ID so we can call the unstable method - Span { expn_id: cx.backtrace(), .. trait_span } + Span { expn_id: cx.backtrace(), ..trait_span } } else { field.span }; @@ -131,15 +132,15 @@ fn cs_clone( ctor_path = cx.path(trait_span, vec![substr.type_ident, variant.node.name]); all_fields = af; vdata = &variant.node.data; - }, - EnumNonMatchingCollapsed (..) => { + } + EnumNonMatchingCollapsed(..) => { cx.span_bug(trait_span, &format!("non-matching enum variants in \ - `derive({})`", name)) + `derive({})`", + name)) } StaticEnum(..) | StaticStruct(..) => { - cx.span_bug(trait_span, - &format!("static method in `derive({})`", name)) + cx.span_bug(trait_span, &format!("static method in `derive({})`", name)) } } @@ -153,17 +154,20 @@ fn cs_clone( Mode::Deep => { match *vdata { VariantData::Struct(..) => { - let fields = all_fields.iter().map(|field| { - let ident = match field.name { - Some(i) => i, - None => { - cx.span_bug(trait_span, - &format!("unnamed field in normal struct in \ - `derive({})`", name)) - } - }; - cx.field_imm(field.span, ident, subcall(field)) - }).collect::>(); + let fields = all_fields.iter() + .map(|field| { + let ident = match field.name { + Some(i) => i, + None => { + cx.span_bug(trait_span, + &format!("unnamed field in normal struct in \ + `derive({})`", + name)) + } + }; + cx.field_imm(field.span, ident, subcall(field)) + }) + .collect::>(); cx.expr_struct(trait_span, ctor_path, fields) } @@ -172,9 +176,7 @@ fn cs_clone( let path = cx.expr_path(ctor_path); cx.expr_call(trait_span, path, subcalls) } - VariantData::Unit(..) => { - cx.expr_path(ctor_path) - } + VariantData::Unit(..) => cx.expr_path(ctor_path), } } } diff --git a/src/libsyntax_ext/deriving/cmp/eq.rs b/src/libsyntax_ext/deriving/cmp/eq.rs index 9c5072eeb3e0b..2ab0f0ff54669 100644 --- a/src/libsyntax_ext/deriving/cmp/eq.rs +++ b/src/libsyntax_ext/deriving/cmp/eq.rs @@ -11,8 +11,8 @@ use deriving::generic::*; use deriving::generic::ty::*; -use syntax::ast::{MetaItem, Expr}; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ast::{Expr, MetaItem}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; @@ -22,30 +22,27 @@ pub fn expand_deriving_eq(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { fn cs_total_eq_assert(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { - cs_same_method( - |cx, span, exprs| { - // create `a.(); b.(); c.(); ...` - // (where method is `assert_receiver_is_total_eq`) - let stmts = exprs.into_iter().map(|e| cx.stmt_expr(e)).collect(); - let block = cx.block(span, stmts); - cx.expr_block(block) - }, - Box::new(|cx, sp, _, _| { - cx.span_bug(sp, "non matching enums in derive(Eq)?") }), - cx, - span, - substr - ) + cs_same_method(|cx, span, exprs| { + // create `a.(); b.(); c.(); ...` + // (where method is `assert_receiver_is_total_eq`) + let stmts = exprs.into_iter().map(|e| cx.stmt_expr(e)).collect(); + let block = cx.block(span, stmts); + cx.expr_block(block) + }, + Box::new(|cx, sp, _, _| { + cx.span_bug(sp, "non matching enums in derive(Eq)?") + }), + cx, + span, + substr) } let inline = cx.meta_word(span, InternedString::new("inline")); let hidden = cx.meta_word(span, InternedString::new("hidden")); - let doc = cx.meta_list(span, InternedString::new("doc"), vec!(hidden)); - let attrs = vec!(cx.attribute(span, inline), - cx.attribute(span, doc)); + let doc = cx.meta_list(span, InternedString::new("doc"), vec![hidden]); + let attrs = vec![cx.attribute(span, inline), cx.attribute(span, doc)]; let trait_def = TraitDef { span: span, attributes: Vec::new(), @@ -53,21 +50,19 @@ pub fn expand_deriving_eq(cx: &mut ExtCtxt, additional_bounds: Vec::new(), generics: LifetimeBounds::empty(), is_unsafe: false, - methods: vec!( - MethodDef { - name: "assert_receiver_is_total_eq", - generics: LifetimeBounds::empty(), - explicit_self: borrowed_explicit_self(), - args: vec!(), - ret_ty: nil_ty(), - attributes: attrs, - is_unsafe: false, - unify_fieldless_variants: true, - combine_substructure: combine_substructure(Box::new(|a, b, c| { - cs_total_eq_assert(a, b, c) - })) - } - ), + methods: vec![MethodDef { + name: "assert_receiver_is_total_eq", + generics: LifetimeBounds::empty(), + explicit_self: borrowed_explicit_self(), + args: vec![], + ret_ty: nil_ty(), + attributes: attrs, + is_unsafe: false, + unify_fieldless_variants: true, + combine_substructure: combine_substructure(Box::new(|a, b, c| { + cs_total_eq_assert(a, b, c) + })), + }], associated_types: Vec::new(), }; trait_def.expand(cx, mitem, item, push) diff --git a/src/libsyntax_ext/deriving/cmp/ord.rs b/src/libsyntax_ext/deriving/cmp/ord.rs index cbd7ac0eadad0..8ae77e79310b2 100644 --- a/src/libsyntax_ext/deriving/cmp/ord.rs +++ b/src/libsyntax_ext/deriving/cmp/ord.rs @@ -11,8 +11,8 @@ use deriving::generic::*; use deriving::generic::ty::*; -use syntax::ast::{MetaItem, Expr, self}; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ast::{self, Expr, MetaItem}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; @@ -22,10 +22,9 @@ pub fn expand_deriving_ord(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { let inline = cx.meta_word(span, InternedString::new("inline")); - let attrs = vec!(cx.attribute(span, inline)); + let attrs = vec![cx.attribute(span, inline)]; let trait_def = TraitDef { span: span, attributes: Vec::new(), @@ -33,21 +32,19 @@ pub fn expand_deriving_ord(cx: &mut ExtCtxt, additional_bounds: Vec::new(), generics: LifetimeBounds::empty(), is_unsafe: false, - methods: vec!( - MethodDef { - name: "cmp", - generics: LifetimeBounds::empty(), - explicit_self: borrowed_explicit_self(), - args: vec!(borrowed_self()), - ret_ty: Literal(path_std!(cx, core::cmp::Ordering)), - attributes: attrs, - is_unsafe: false, - unify_fieldless_variants: true, - combine_substructure: combine_substructure(Box::new(|a, b, c| { - cs_cmp(a, b, c) - })), - } - ), + methods: vec![MethodDef { + name: "cmp", + generics: LifetimeBounds::empty(), + explicit_self: borrowed_explicit_self(), + args: vec![borrowed_self()], + ret_ty: Literal(path_std!(cx, core::cmp::Ordering)), + attributes: attrs, + is_unsafe: false, + unify_fieldless_variants: true, + combine_substructure: combine_substructure(Box::new(|a, b, c| { + cs_cmp(a, b, c) + })), + }], associated_types: Vec::new(), }; @@ -57,76 +54,73 @@ pub fn expand_deriving_ord(cx: &mut ExtCtxt, pub fn ordering_collapsed(cx: &mut ExtCtxt, span: Span, - self_arg_tags: &[ast::Ident]) -> P { + self_arg_tags: &[ast::Ident]) + -> P { let lft = cx.expr_ident(span, self_arg_tags[0]); let rgt = cx.expr_addr_of(span, cx.expr_ident(span, self_arg_tags[1])); cx.expr_method_call(span, lft, cx.ident_of("cmp"), vec![rgt]) } -pub fn cs_cmp(cx: &mut ExtCtxt, span: Span, - substr: &Substructure) -> P { +pub fn cs_cmp(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { let test_id = cx.ident_of("__cmp"); - let equals_path = cx.path_global(span, - cx.std_path(&["cmp", "Ordering", "Equal"])); + let equals_path = cx.path_global(span, cx.std_path(&["cmp", "Ordering", "Equal"])); let cmp_path = cx.std_path(&["cmp", "Ord", "cmp"]); - /* - Builds: + // Builds: + // + // match ::std::cmp::Ord::cmp(&self_field1, &other_field1) { + // ::std::cmp::Ordering::Equal => + // match ::std::cmp::Ord::cmp(&self_field2, &other_field2) { + // ::std::cmp::Ordering::Equal => { + // ... + // } + // __cmp => __cmp + // }, + // __cmp => __cmp + // } + // + cs_fold(// foldr nests the if-elses correctly, leaving the first field + // as the outermost one, and the last as the innermost. + false, + |cx, span, old, self_f, other_fs| { + // match new { + // ::std::cmp::Ordering::Equal => old, + // __cmp => __cmp + // } - match ::std::cmp::Ord::cmp(&self_field1, &other_field1) { - ::std::cmp::Ordering::Equal => - match ::std::cmp::Ord::cmp(&self_field2, &other_field2) { - ::std::cmp::Ordering::Equal => { - ... - } - __cmp => __cmp - }, - __cmp => __cmp - } - */ - cs_fold( - // foldr nests the if-elses correctly, leaving the first field - // as the outermost one, and the last as the innermost. - false, - |cx, span, old, self_f, other_fs| { - // match new { - // ::std::cmp::Ordering::Equal => old, - // __cmp => __cmp - // } - - let new = { - let other_f = match (other_fs.len(), other_fs.get(0)) { - (1, Some(o_f)) => o_f, - _ => cx.span_bug(span, "not exactly 2 arguments in `derive(Ord)`"), - }; + let new = { + let other_f = match (other_fs.len(), other_fs.get(0)) { + (1, Some(o_f)) => o_f, + _ => cx.span_bug(span, "not exactly 2 arguments in `derive(Ord)`"), + }; - let args = vec![ + let args = vec![ cx.expr_addr_of(span, self_f), cx.expr_addr_of(span, other_f.clone()), ]; - cx.expr_call_global(span, cmp_path.clone(), args) - }; + cx.expr_call_global(span, cmp_path.clone(), args) + }; - let eq_arm = cx.arm(span, - vec![cx.pat_enum(span, - equals_path.clone(), - vec![])], - old); - let neq_arm = cx.arm(span, - vec![cx.pat_ident(span, test_id)], - cx.expr_ident(span, test_id)); + let eq_arm = cx.arm(span, + vec![cx.pat_enum(span, equals_path.clone(), vec![])], + old); + let neq_arm = cx.arm(span, + vec![cx.pat_ident(span, test_id)], + cx.expr_ident(span, test_id)); - cx.expr_match(span, new, vec![eq_arm, neq_arm]) - }, - cx.expr_path(equals_path.clone()), - Box::new(|cx, span, (self_args, tag_tuple), _non_self_args| { - if self_args.len() != 2 { - cx.span_bug(span, "not exactly 2 arguments in `derive(Ord)`") - } else { - ordering_collapsed(cx, span, tag_tuple) - } - }), - cx, span, substr) + cx.expr_match(span, new, vec![eq_arm, neq_arm]) + }, + cx.expr_path(equals_path.clone()), + Box::new(|cx, span, (self_args, tag_tuple), _non_self_args| { + if self_args.len() != 2 { + cx.span_bug(span, "not exactly 2 arguments in `derive(Ord)`") + } else { + ordering_collapsed(cx, span, tag_tuple) + } + }), + cx, + span, + substr) } diff --git a/src/libsyntax_ext/deriving/cmp/partial_eq.rs b/src/libsyntax_ext/deriving/cmp/partial_eq.rs index b5a8167fb5550..f70e0cf4ac457 100644 --- a/src/libsyntax_ext/deriving/cmp/partial_eq.rs +++ b/src/libsyntax_ext/deriving/cmp/partial_eq.rs @@ -11,8 +11,8 @@ use deriving::generic::*; use deriving::generic::ty::*; -use syntax::ast::{MetaItem, Expr, BinOpKind}; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ast::{BinOpKind, Expr, MetaItem}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; @@ -22,43 +22,44 @@ pub fn expand_deriving_partial_eq(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { // structures are equal if all fields are equal, and non equal, if // any fields are not equal or if the enum variants are different fn cs_eq(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { - cs_fold( - true, // use foldl - |cx, span, subexpr, self_f, other_fs| { - let other_f = match (other_fs.len(), other_fs.get(0)) { - (1, Some(o_f)) => o_f, - _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialEq)`") - }; + cs_fold(true, // use foldl + |cx, span, subexpr, self_f, other_fs| { + let other_f = match (other_fs.len(), other_fs.get(0)) { + (1, Some(o_f)) => o_f, + _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialEq)`"), + }; - let eq = cx.expr_binary(span, BinOpKind::Eq, self_f, other_f.clone()); + let eq = cx.expr_binary(span, BinOpKind::Eq, self_f, other_f.clone()); - cx.expr_binary(span, BinOpKind::And, subexpr, eq) - }, - cx.expr_bool(span, true), - Box::new(|cx, span, _, _| cx.expr_bool(span, false)), - cx, span, substr) + cx.expr_binary(span, BinOpKind::And, subexpr, eq) + }, + cx.expr_bool(span, true), + Box::new(|cx, span, _, _| cx.expr_bool(span, false)), + cx, + span, + substr) } fn cs_ne(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { - cs_fold( - true, // use foldl - |cx, span, subexpr, self_f, other_fs| { - let other_f = match (other_fs.len(), other_fs.get(0)) { - (1, Some(o_f)) => o_f, - _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialEq)`") - }; + cs_fold(true, // use foldl + |cx, span, subexpr, self_f, other_fs| { + let other_f = match (other_fs.len(), other_fs.get(0)) { + (1, Some(o_f)) => o_f, + _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialEq)`"), + }; - let eq = cx.expr_binary(span, BinOpKind::Ne, self_f, other_f.clone()); + let eq = cx.expr_binary(span, BinOpKind::Ne, self_f, other_f.clone()); - cx.expr_binary(span, BinOpKind::Or, subexpr, eq) - }, - cx.expr_bool(span, false), - Box::new(|cx, span, _, _| cx.expr_bool(span, true)), - cx, span, substr) + cx.expr_binary(span, BinOpKind::Or, subexpr, eq) + }, + cx.expr_bool(span, false), + Box::new(|cx, span, _, _| cx.expr_bool(span, true)), + cx, + span, + substr) } macro_rules! md { diff --git a/src/libsyntax_ext/deriving/cmp/partial_ord.rs b/src/libsyntax_ext/deriving/cmp/partial_ord.rs index 26c14ae934f72..10a9738742e44 100644 --- a/src/libsyntax_ext/deriving/cmp/partial_ord.rs +++ b/src/libsyntax_ext/deriving/cmp/partial_ord.rs @@ -13,8 +13,8 @@ pub use self::OrderingOp::*; use deriving::generic::*; use deriving::generic::ty::*; -use syntax::ast::{MetaItem, Expr, BinOpKind, self}; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ast::{self, BinOpKind, Expr, MetaItem}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; @@ -24,8 +24,7 @@ pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { macro_rules! md { ($name:expr, $op:expr, $equal:expr) => { { let inline = cx.meta_word(span, InternedString::new("inline")); @@ -53,7 +52,7 @@ pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt, true)); let inline = cx.meta_word(span, InternedString::new("inline")); - let attrs = vec!(cx.attribute(span, inline)); + let attrs = vec![cx.attribute(span, inline)]; let partial_cmp_def = MethodDef { name: "partial_cmp", @@ -66,7 +65,7 @@ pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt, unify_fieldless_variants: true, combine_substructure: combine_substructure(Box::new(|cx, span, substr| { cs_partial_cmp(cx, span, substr) - })) + })), }; // avoid defining extra methods if we can @@ -75,13 +74,11 @@ pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt, let methods = if is_type_without_fields(item) { vec![partial_cmp_def] } else { - vec![ - partial_cmp_def, - md!("lt", true, false), - md!("le", true, true), - md!("gt", false, false), - md!("ge", false, true) - ] + vec![partial_cmp_def, + md!("lt", true, false), + md!("le", true, true), + md!("gt", false, false), + md!("ge", false, true)] }; let trait_def = TraitDef { @@ -99,142 +96,146 @@ pub fn expand_deriving_partial_ord(cx: &mut ExtCtxt, #[derive(Copy, Clone)] pub enum OrderingOp { - PartialCmpOp, LtOp, LeOp, GtOp, GeOp, + PartialCmpOp, + LtOp, + LeOp, + GtOp, + GeOp, } pub fn some_ordering_collapsed(cx: &mut ExtCtxt, span: Span, op: OrderingOp, - self_arg_tags: &[ast::Ident]) -> P { + self_arg_tags: &[ast::Ident]) + -> P { let lft = cx.expr_ident(span, self_arg_tags[0]); let rgt = cx.expr_addr_of(span, cx.expr_ident(span, self_arg_tags[1])); let op_str = match op { PartialCmpOp => "partial_cmp", - LtOp => "lt", LeOp => "le", - GtOp => "gt", GeOp => "ge", + LtOp => "lt", + LeOp => "le", + GtOp => "gt", + GeOp => "ge", }; cx.expr_method_call(span, lft, cx.ident_of(op_str), vec![rgt]) } -pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span, - substr: &Substructure) -> P { +pub fn cs_partial_cmp(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { let test_id = cx.ident_of("__cmp"); - let ordering = cx.path_global(span, - cx.std_path(&["cmp", "Ordering", "Equal"])); + let ordering = cx.path_global(span, cx.std_path(&["cmp", "Ordering", "Equal"])); let ordering_expr = cx.expr_path(ordering.clone()); let equals_expr = cx.expr_some(span, ordering_expr); let partial_cmp_path = cx.std_path(&["cmp", "PartialOrd", "partial_cmp"]); - /* - Builds: - - match ::std::cmp::PartialOrd::partial_cmp(&self_field1, &other_field1) { - ::std::option::Option::Some(::std::cmp::Ordering::Equal) => - match ::std::cmp::PartialOrd::partial_cmp(&self_field2, &other_field2) { - ::std::option::Option::Some(::std::cmp::Ordering::Equal) => { - ... - } - __cmp => __cmp - }, - __cmp => __cmp - } - */ - cs_fold( - // foldr nests the if-elses correctly, leaving the first field - // as the outermost one, and the last as the innermost. - false, - |cx, span, old, self_f, other_fs| { - // match new { - // Some(::std::cmp::Ordering::Equal) => old, - // __cmp => __cmp - // } - - let new = { - let other_f = match (other_fs.len(), other_fs.get(0)) { - (1, Some(o_f)) => o_f, - _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`"), - }; - - let args = vec![ + // Builds: + // + // match ::std::cmp::PartialOrd::partial_cmp(&self_field1, &other_field1) { + // ::std::option::Option::Some(::std::cmp::Ordering::Equal) => + // match ::std::cmp::PartialOrd::partial_cmp(&self_field2, &other_field2) { + // ::std::option::Option::Some(::std::cmp::Ordering::Equal) => { + // ... + // } + // __cmp => __cmp + // }, + // __cmp => __cmp + // } + // + cs_fold(// foldr nests the if-elses correctly, leaving the first field + // as the outermost one, and the last as the innermost. + false, + |cx, span, old, self_f, other_fs| { + // match new { + // Some(::std::cmp::Ordering::Equal) => old, + // __cmp => __cmp + // } + + let new = { + let other_f = match (other_fs.len(), other_fs.get(0)) { + (1, Some(o_f)) => o_f, + _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`"), + }; + + let args = vec![ cx.expr_addr_of(span, self_f), cx.expr_addr_of(span, other_f.clone()), ]; - cx.expr_call_global(span, partial_cmp_path.clone(), args) - }; - - let eq_arm = cx.arm(span, - vec![cx.pat_some(span, - cx.pat_enum(span, - ordering.clone(), - vec![]))], - old); - let neq_arm = cx.arm(span, - vec![cx.pat_ident(span, test_id)], - cx.expr_ident(span, test_id)); - - cx.expr_match(span, new, vec![eq_arm, neq_arm]) - }, - equals_expr.clone(), - Box::new(|cx, span, (self_args, tag_tuple), _non_self_args| { - if self_args.len() != 2 { - cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`") - } else { - some_ordering_collapsed(cx, span, PartialCmpOp, tag_tuple) - } - }), - cx, span, substr) + cx.expr_call_global(span, partial_cmp_path.clone(), args) + }; + + let eq_arm = cx.arm(span, + vec![cx.pat_some(span, cx.pat_enum(span, ordering.clone(), vec![]))], + old); + let neq_arm = cx.arm(span, + vec![cx.pat_ident(span, test_id)], + cx.expr_ident(span, test_id)); + + cx.expr_match(span, new, vec![eq_arm, neq_arm]) + }, + equals_expr.clone(), + Box::new(|cx, span, (self_args, tag_tuple), _non_self_args| { + if self_args.len() != 2 { + cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`") + } else { + some_ordering_collapsed(cx, span, PartialCmpOp, tag_tuple) + } + }), + cx, + span, + substr) } /// Strict inequality. -fn cs_op(less: bool, equal: bool, cx: &mut ExtCtxt, - span: Span, substr: &Substructure) -> P { +fn cs_op(less: bool, equal: bool, cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { let op = if less { BinOpKind::Lt } else { BinOpKind::Gt }; - cs_fold( - false, // need foldr, - |cx, span, subexpr, self_f, other_fs| { - /* - build up a series of chain ||'s and &&'s from the inside - out (hence foldr) to get lexical ordering, i.e. for op == - `ast::lt` - - ``` - self.f1 < other.f1 || (!(other.f1 < self.f1) && - (self.f2 < other.f2 || (!(other.f2 < self.f2) && - (false) - )) - ) - ``` - - The optimiser should remove the redundancy. We explicitly - get use the binops to avoid auto-deref dereferencing too many - layers of pointers, if the type includes pointers. - */ - let other_f = match (other_fs.len(), other_fs.get(0)) { - (1, Some(o_f)) => o_f, - _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`") + cs_fold(false, // need foldr, + |cx, span, subexpr, self_f, other_fs| { + // build up a series of chain ||'s and &&'s from the inside + // out (hence foldr) to get lexical ordering, i.e. for op == + // `ast::lt` + // + // ``` + // self.f1 < other.f1 || (!(other.f1 < self.f1) && + // (self.f2 < other.f2 || (!(other.f2 < self.f2) && + // (false) + // )) + // ) + // ``` + // + // The optimiser should remove the redundancy. We explicitly + // get use the binops to avoid auto-deref dereferencing too many + // layers of pointers, if the type includes pointers. + // + let other_f = match (other_fs.len(), other_fs.get(0)) { + (1, Some(o_f)) => o_f, + _ => cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`"), + }; + + let cmp = cx.expr_binary(span, op, self_f.clone(), other_f.clone()); + + let not_cmp = cx.expr_unary(span, + ast::UnOp::Not, + cx.expr_binary(span, op, other_f.clone(), self_f)); + + let and = cx.expr_binary(span, BinOpKind::And, not_cmp, subexpr); + cx.expr_binary(span, BinOpKind::Or, cmp, and) + }, + cx.expr_bool(span, equal), + Box::new(|cx, span, (self_args, tag_tuple), _non_self_args| { + if self_args.len() != 2 { + cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`") + } else { + let op = match (less, equal) { + (true, true) => LeOp, + (true, false) => LtOp, + (false, true) => GeOp, + (false, false) => GtOp, }; - - let cmp = cx.expr_binary(span, op, self_f.clone(), other_f.clone()); - - let not_cmp = cx.expr_unary(span, ast::UnOp::Not, - cx.expr_binary(span, op, other_f.clone(), self_f)); - - let and = cx.expr_binary(span, BinOpKind::And, not_cmp, subexpr); - cx.expr_binary(span, BinOpKind::Or, cmp, and) - }, - cx.expr_bool(span, equal), - Box::new(|cx, span, (self_args, tag_tuple), _non_self_args| { - if self_args.len() != 2 { - cx.span_bug(span, "not exactly 2 arguments in `derive(PartialOrd)`") - } else { - let op = match (less, equal) { - (true, true) => LeOp, (true, false) => LtOp, - (false, true) => GeOp, (false, false) => GtOp, - }; - some_ordering_collapsed(cx, span, op, tag_tuple) - } - }), - cx, span, substr) + some_ordering_collapsed(cx, span, op, tag_tuple) + } + }), + cx, + span, + substr) } diff --git a/src/libsyntax_ext/deriving/debug.rs b/src/libsyntax_ext/deriving/debug.rs index 34c872bef11d1..a31c695e36049 100644 --- a/src/libsyntax_ext/deriving/debug.rs +++ b/src/libsyntax_ext/deriving/debug.rs @@ -12,19 +12,18 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast; -use syntax::ast::{MetaItem, Expr}; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ast::{Expr, MetaItem}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::parse::token; use syntax::ptr::P; -use syntax_pos::{Span, DUMMY_SP}; +use syntax_pos::{DUMMY_SP, Span}; pub fn expand_deriving_debug(cx: &mut ExtCtxt, - span: Span, - mitem: &MetaItem, - item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + span: Span, + mitem: &MetaItem, + item: &Annotatable, + push: &mut FnMut(Annotatable)) { // &mut ::std::fmt::Formatter let fmtr = Ptr(Box::new(Literal(path_std!(cx, core::fmt::Formatter))), Borrowed(None, ast::Mutability::Mutable)); @@ -36,57 +35,54 @@ pub fn expand_deriving_debug(cx: &mut ExtCtxt, additional_bounds: Vec::new(), generics: LifetimeBounds::empty(), is_unsafe: false, - methods: vec![ - MethodDef { - name: "fmt", - generics: LifetimeBounds::empty(), - explicit_self: borrowed_explicit_self(), - args: vec!(fmtr), - ret_ty: Literal(path_std!(cx, core::fmt::Result)), - attributes: Vec::new(), - is_unsafe: false, - unify_fieldless_variants: false, - combine_substructure: combine_substructure(Box::new(|a, b, c| { - show_substructure(a, b, c) - })) - } - ], + methods: vec![MethodDef { + name: "fmt", + generics: LifetimeBounds::empty(), + explicit_self: borrowed_explicit_self(), + args: vec![fmtr], + ret_ty: Literal(path_std!(cx, core::fmt::Result)), + attributes: Vec::new(), + is_unsafe: false, + unify_fieldless_variants: false, + combine_substructure: combine_substructure(Box::new(|a, b, c| { + show_substructure(a, b, c) + })), + }], associated_types: Vec::new(), }; trait_def.expand(cx, mitem, item, push) } /// We use the debug builders to do the heavy lifting here -fn show_substructure(cx: &mut ExtCtxt, span: Span, - substr: &Substructure) -> P { +fn show_substructure(cx: &mut ExtCtxt, span: Span, substr: &Substructure) -> P { // build fmt.debug_struct().field(, &)....build() // or fmt.debug_tuple().field(&)....build() // based on the "shape". let (ident, is_struct) = match *substr.fields { Struct(vdata, _) => (substr.type_ident, vdata.is_struct()), EnumMatching(_, v, _) => (v.node.name, v.node.data.is_struct()), - EnumNonMatchingCollapsed(..) | StaticStruct(..) | StaticEnum(..) => { - cx.span_bug(span, "nonsensical .fields in `#[derive(Debug)]`") - } + EnumNonMatchingCollapsed(..) | + StaticStruct(..) | + StaticEnum(..) => cx.span_bug(span, "nonsensical .fields in `#[derive(Debug)]`"), }; // We want to make sure we have the expn_id set so that we can use unstable methods - let span = Span { expn_id: cx.backtrace(), .. span }; - let name = cx.expr_lit(span, ast::LitKind::Str(ident.name.as_str(), ast::StrStyle::Cooked)); + let span = Span { expn_id: cx.backtrace(), ..span }; + let name = cx.expr_lit(span, + ast::LitKind::Str(ident.name.as_str(), ast::StrStyle::Cooked)); let builder = token::str_to_ident("builder"); let builder_expr = cx.expr_ident(span, builder.clone()); let fmt = substr.nonself_args[0].clone(); let mut stmts = match *substr.fields { - Struct(_, ref fields) | EnumMatching(_, _, ref fields) => { + Struct(_, ref fields) | + EnumMatching(_, _, ref fields) => { let mut stmts = vec![]; if !is_struct { // tuple struct/"normal" variant - let expr = cx.expr_method_call(span, - fmt, - token::str_to_ident("debug_tuple"), - vec![name]); + let expr = + cx.expr_method_call(span, fmt, token::str_to_ident("debug_tuple"), vec![name]); stmts.push(cx.stmt_let(DUMMY_SP, true, builder, expr)); for field in fields { @@ -105,16 +101,14 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span, } } else { // normal struct/struct variant - let expr = cx.expr_method_call(span, - fmt, - token::str_to_ident("debug_struct"), - vec![name]); + let expr = + cx.expr_method_call(span, fmt, token::str_to_ident("debug_struct"), vec![name]); stmts.push(cx.stmt_let(DUMMY_SP, true, builder, expr)); for field in fields { - let name = cx.expr_lit(field.span, ast::LitKind::Str( - field.name.unwrap().name.as_str(), - ast::StrStyle::Cooked)); + let name = cx.expr_lit(field.span, + ast::LitKind::Str(field.name.unwrap().name.as_str(), + ast::StrStyle::Cooked)); // Use double indirection to make sure this works for unsized types let field = cx.expr_addr_of(field.span, field.self_.clone()); @@ -128,22 +122,17 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span, } stmts } - _ => unreachable!() + _ => unreachable!(), }; - let expr = cx.expr_method_call(span, - builder_expr, - token::str_to_ident("finish"), - vec![]); + let expr = cx.expr_method_call(span, builder_expr, token::str_to_ident("finish"), vec![]); stmts.push(cx.stmt_expr(expr)); let block = cx.block(span, stmts); cx.expr_block(block) } -fn stmt_let_undescore(cx: &mut ExtCtxt, - sp: Span, - expr: P) -> ast::Stmt { +fn stmt_let_undescore(cx: &mut ExtCtxt, sp: Span, expr: P) -> ast::Stmt { let local = P(ast::Local { pat: cx.pat_wild(sp), ty: None, diff --git a/src/libsyntax_ext/deriving/decodable.rs b/src/libsyntax_ext/deriving/decodable.rs index 488402c48f70a..9a332227053c7 100644 --- a/src/libsyntax_ext/deriving/decodable.rs +++ b/src/libsyntax_ext/deriving/decodable.rs @@ -15,8 +15,8 @@ use deriving::generic::*; use deriving::generic::ty::*; use syntax::ast; -use syntax::ast::{MetaItem, Expr, Mutability}; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ast::{Expr, MetaItem, Mutability}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::parse::token; @@ -27,8 +27,7 @@ pub fn expand_deriving_rustc_decodable(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { expand_deriving_decodable_imp(cx, span, mitem, item, push, "rustc_serialize") } @@ -36,8 +35,7 @@ pub fn expand_deriving_decodable(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { expand_deriving_decodable_imp(cx, span, mitem, item, push, "serialize") } @@ -46,13 +44,13 @@ fn expand_deriving_decodable_imp(cx: &mut ExtCtxt, mitem: &MetaItem, item: &Annotatable, push: &mut FnMut(Annotatable), - krate: &'static str) -{ + krate: &'static str) { if cx.crate_root != Some("std") { // FIXME(#21880): lift this requirement. - cx.span_err(span, "this trait cannot be derived with #![no_std] \ + cx.span_err(span, + "this trait cannot be derived with #![no_std] \ or #![no_core]"); - return + return; } let typaram = &*deriving::hygienic_type_parameter(item, "__D"); @@ -60,50 +58,50 @@ fn expand_deriving_decodable_imp(cx: &mut ExtCtxt, let trait_def = TraitDef { span: span, attributes: Vec::new(), - path: Path::new_(vec!(krate, "Decodable"), None, vec!(), true), + path: Path::new_(vec![krate, "Decodable"], None, vec![], true), additional_bounds: Vec::new(), generics: LifetimeBounds::empty(), is_unsafe: false, - methods: vec!( - MethodDef { - name: "decode", - generics: LifetimeBounds { - lifetimes: Vec::new(), - bounds: vec![(typaram, - vec![Path::new_(vec!(krate, "Decoder"), None, vec!(), true)])] - }, - explicit_self: None, - args: vec!(Ptr(Box::new(Literal(Path::new_local(typaram))), - Borrowed(None, Mutability::Mutable))), - ret_ty: Literal(Path::new_( - pathvec_std!(cx, core::result::Result), - None, - vec!(Box::new(Self_), Box::new(Literal(Path::new_( + methods: vec![MethodDef { + name: "decode", + generics: LifetimeBounds { + lifetimes: Vec::new(), + bounds: vec![(typaram, + vec![Path::new_(vec![krate, "Decoder"], + None, + vec![], + true)])], + }, + explicit_self: None, + args: vec![Ptr(Box::new(Literal(Path::new_local(typaram))), + Borrowed(None, Mutability::Mutable))], + ret_ty: + Literal(Path::new_(pathvec_std!(cx, core::result::Result), + None, + vec!(Box::new(Self_), Box::new(Literal(Path::new_( vec![typaram, "Error"], None, vec![], false )))), - true - )), - attributes: Vec::new(), - is_unsafe: false, - unify_fieldless_variants: false, - combine_substructure: combine_substructure(Box::new(|a, b, c| { - decodable_substructure(a, b, c, krate) - })), - } - ), + true)), + attributes: Vec::new(), + is_unsafe: false, + unify_fieldless_variants: false, + combine_substructure: combine_substructure(Box::new(|a, b, c| { + decodable_substructure(a, b, c, krate) + })), + }], associated_types: Vec::new(), }; trait_def.expand(cx, mitem, item, push) } -fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span, +fn decodable_substructure(cx: &mut ExtCtxt, + trait_span: Span, substr: &Substructure, - krate: &str) -> P { + krate: &str) + -> P { let decoder = substr.nonself_args[0].clone(); - let recurse = vec!(cx.ident_of(krate), - cx.ident_of("Decodable"), - cx.ident_of("decode")); + let recurse = vec![cx.ident_of(krate), cx.ident_of("Decodable"), cx.ident_of("decode")]; let exprdecode = cx.expr_path(cx.path_global(trait_span, recurse)); // throw an underscore in front to suppress unused variable warnings let blkarg = cx.ident_of("_d"); @@ -113,31 +111,28 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span, StaticStruct(_, ref summary) => { let nfields = match *summary { Unnamed(ref fields) => fields.len(), - Named(ref fields) => fields.len() + Named(ref fields) => fields.len(), }; let read_struct_field = cx.ident_of("read_struct_field"); let path = cx.path_ident(trait_span, substr.type_ident); - let result = decode_static_fields(cx, - trait_span, - path, - summary, - |cx, span, name, field| { - cx.expr_try(span, - cx.expr_method_call(span, blkdecoder.clone(), read_struct_field, - vec!(cx.expr_str(span, name), - cx.expr_usize(span, field), - exprdecode.clone()))) - }); + let result = + decode_static_fields(cx, trait_span, path, summary, |cx, span, name, field| { + cx.expr_try(span, + cx.expr_method_call(span, + blkdecoder.clone(), + read_struct_field, + vec![cx.expr_str(span, name), + cx.expr_usize(span, field), + exprdecode.clone()])) + }); let result = cx.expr_ok(trait_span, result); cx.expr_method_call(trait_span, decoder, cx.ident_of("read_struct"), - vec!( - cx.expr_str(trait_span, substr.type_ident.name.as_str()), - cx.expr_usize(trait_span, nfields), - cx.lambda_expr_1(trait_span, result, blkarg) - )) + vec![cx.expr_str(trait_span, substr.type_ident.name.as_str()), + cx.expr_usize(trait_span, nfields), + cx.lambda_expr_1(trait_span, result, blkarg)]) } StaticEnum(_, ref fields) => { let variant = cx.ident_of("i"); @@ -150,42 +145,39 @@ fn decodable_substructure(cx: &mut ExtCtxt, trait_span: Span, variants.push(cx.expr_str(v_span, ident.name.as_str())); let path = cx.path(trait_span, vec![substr.type_ident, ident]); - let decoded = decode_static_fields(cx, - v_span, - path, - parts, - |cx, span, _, field| { + let decoded = decode_static_fields(cx, v_span, path, parts, |cx, span, _, field| { let idx = cx.expr_usize(span, field); cx.expr_try(span, - cx.expr_method_call(span, blkdecoder.clone(), rvariant_arg, - vec!(idx, exprdecode.clone()))) + cx.expr_method_call(span, + blkdecoder.clone(), + rvariant_arg, + vec![idx, exprdecode.clone()])) }); arms.push(cx.arm(v_span, - vec!(cx.pat_lit(v_span, cx.expr_usize(v_span, i))), + vec![cx.pat_lit(v_span, cx.expr_usize(v_span, i))], decoded)); } arms.push(cx.arm_unreachable(trait_span)); - let result = cx.expr_ok(trait_span, - cx.expr_match(trait_span, - cx.expr_ident(trait_span, variant), arms)); - let lambda = cx.lambda_expr(trait_span, vec!(blkarg, variant), result); + let result = + cx.expr_ok(trait_span, + cx.expr_match(trait_span, cx.expr_ident(trait_span, variant), arms)); + let lambda = cx.lambda_expr(trait_span, vec![blkarg, variant], result); let variant_vec = cx.expr_vec(trait_span, variants); let variant_vec = cx.expr_addr_of(trait_span, variant_vec); - let result = cx.expr_method_call(trait_span, blkdecoder, + let result = cx.expr_method_call(trait_span, + blkdecoder, cx.ident_of("read_enum_variant"), - vec!(variant_vec, lambda)); + vec![variant_vec, lambda]); cx.expr_method_call(trait_span, decoder, cx.ident_of("read_enum"), - vec!( - cx.expr_str(trait_span, substr.type_ident.name.as_str()), - cx.lambda_expr_1(trait_span, result, blkarg) - )) + vec![cx.expr_str(trait_span, substr.type_ident.name.as_str()), + cx.lambda_expr_1(trait_span, result, blkarg)]) } - _ => cx.bug("expected StaticEnum or StaticStruct in derive(Decodable)") + _ => cx.bug("expected StaticEnum or StaticStruct in derive(Decodable)"), }; } @@ -197,8 +189,8 @@ fn decode_static_fields(cx: &mut ExtCtxt, outer_pat_path: ast::Path, fields: &StaticFields, mut getarg: F) - -> P where - F: FnMut(&mut ExtCtxt, Span, InternedString, usize) -> P, + -> P + where F: FnMut(&mut ExtCtxt, Span, InternedString, usize) -> P { match *fields { Unnamed(ref fields) => { @@ -206,21 +198,28 @@ fn decode_static_fields(cx: &mut ExtCtxt, if fields.is_empty() { path_expr } else { - let fields = fields.iter().enumerate().map(|(i, &span)| { - getarg(cx, span, - token::intern_and_get_ident(&format!("_field{}", i)), - i) - }).collect(); + let fields = fields.iter() + .enumerate() + .map(|(i, &span)| { + getarg(cx, + span, + token::intern_and_get_ident(&format!("_field{}", i)), + i) + }) + .collect(); cx.expr_call(trait_span, path_expr, fields) } } Named(ref fields) => { // use the field's span to get nicer error messages. - let fields = fields.iter().enumerate().map(|(i, &(ident, span))| { - let arg = getarg(cx, span, ident.name.as_str(), i); - cx.field_imm(span, ident, arg) - }).collect(); + let fields = fields.iter() + .enumerate() + .map(|(i, &(ident, span))| { + let arg = getarg(cx, span, ident.name.as_str(), i); + cx.field_imm(span, ident, arg) + }) + .collect(); cx.expr_struct(trait_span, outer_pat_path, fields) } } diff --git a/src/libsyntax_ext/deriving/default.rs b/src/libsyntax_ext/deriving/default.rs index 2711ccba81914..9df3db938b1f9 100644 --- a/src/libsyntax_ext/deriving/default.rs +++ b/src/libsyntax_ext/deriving/default.rs @@ -11,8 +11,8 @@ use deriving::generic::*; use deriving::generic::ty::*; -use syntax::ast::{MetaItem, Expr}; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ast::{Expr, MetaItem}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::parse::token::InternedString; use syntax::ptr::P; @@ -22,10 +22,9 @@ pub fn expand_deriving_default(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { let inline = cx.meta_word(span, InternedString::new("inline")); - let attrs = vec!(cx.attribute(span, inline)); + let attrs = vec![cx.attribute(span, inline)]; let trait_def = TraitDef { span: span, attributes: Vec::new(), @@ -33,21 +32,19 @@ pub fn expand_deriving_default(cx: &mut ExtCtxt, additional_bounds: Vec::new(), generics: LifetimeBounds::empty(), is_unsafe: false, - methods: vec!( - MethodDef { - name: "default", - generics: LifetimeBounds::empty(), - explicit_self: None, - args: Vec::new(), - ret_ty: Self_, - attributes: attrs, - is_unsafe: false, - unify_fieldless_variants: false, - combine_substructure: combine_substructure(Box::new(|a, b, c| { - default_substructure(a, b, c) - })) - } - ), + methods: vec![MethodDef { + name: "default", + generics: LifetimeBounds::empty(), + explicit_self: None, + args: Vec::new(), + ret_ty: Self_, + attributes: attrs, + is_unsafe: false, + unify_fieldless_variants: false, + combine_substructure: combine_substructure(Box::new(|a, b, c| { + default_substructure(a, b, c) + })), + }], associated_types: Vec::new(), }; trait_def.expand(cx, mitem, item, push) @@ -69,18 +66,19 @@ fn default_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructur } } Named(ref fields) => { - let default_fields = fields.iter().map(|&(ident, span)| { - cx.field_imm(span, ident, default_call(span)) - }).collect(); + let default_fields = fields.iter() + .map(|&(ident, span)| cx.field_imm(span, ident, default_call(span))) + .collect(); cx.expr_struct_ident(trait_span, substr.type_ident, default_fields) } } } StaticEnum(..) => { - cx.span_err(trait_span, "`Default` cannot be derived for enums, only structs"); + cx.span_err(trait_span, + "`Default` cannot be derived for enums, only structs"); // let compilation continue cx.expr_usize(trait_span, 0) } - _ => cx.span_bug(trait_span, "Non-static method in `derive(Default)`") + _ => cx.span_bug(trait_span, "Non-static method in `derive(Default)`"), }; } diff --git a/src/libsyntax_ext/deriving/encodable.rs b/src/libsyntax_ext/deriving/encodable.rs index ad3786212475e..940fdf037711f 100644 --- a/src/libsyntax_ext/deriving/encodable.rs +++ b/src/libsyntax_ext/deriving/encodable.rs @@ -92,8 +92,8 @@ use deriving; use deriving::generic::*; use deriving::generic::ty::*; -use syntax::ast::{MetaItem, Expr, ExprKind, Mutability}; -use syntax::ext::base::{ExtCtxt,Annotatable}; +use syntax::ast::{Expr, ExprKind, MetaItem, Mutability}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::parse::token; use syntax::ptr::P; @@ -103,8 +103,7 @@ pub fn expand_deriving_rustc_encodable(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { expand_deriving_encodable_imp(cx, span, mitem, item, push, "rustc_serialize") } @@ -112,8 +111,7 @@ pub fn expand_deriving_encodable(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { expand_deriving_encodable_imp(cx, span, mitem, item, push, "serialize") } @@ -122,11 +120,11 @@ fn expand_deriving_encodable_imp(cx: &mut ExtCtxt, mitem: &MetaItem, item: &Annotatable, push: &mut FnMut(Annotatable), - krate: &'static str) -{ + krate: &'static str) { if cx.crate_root != Some("std") { // FIXME(#21880): lift this requirement. - cx.span_err(span, "this trait cannot be derived with #![no_std] \ + cx.span_err(span, + "this trait cannot be derived with #![no_std] \ or #![no_core]"); return; } @@ -136,7 +134,7 @@ fn expand_deriving_encodable_imp(cx: &mut ExtCtxt, let trait_def = TraitDef { span: span, attributes: Vec::new(), - path: Path::new_(vec!(krate, "Encodable"), None, vec!(), true), + path: Path::new_(vec![krate, "Encodable"], None, vec![], true), additional_bounds: Vec::new(), generics: LifetimeBounds::empty(), is_unsafe: false, @@ -173,40 +171,38 @@ fn expand_deriving_encodable_imp(cx: &mut ExtCtxt, trait_def.expand(cx, mitem, item, push) } -fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, - substr: &Substructure, krate: &'static str) -> P { +fn encodable_substructure(cx: &mut ExtCtxt, + trait_span: Span, + substr: &Substructure, + krate: &'static str) + -> P { let encoder = substr.nonself_args[0].clone(); // throw an underscore in front to suppress unused variable warnings let blkarg = cx.ident_of("_e"); let blkencoder = cx.expr_ident(trait_span, blkarg); - let fn_path = cx.expr_path(cx.path_global(trait_span, vec![cx.ident_of(krate), - cx.ident_of("Encodable"), - cx.ident_of("encode")])); + let fn_path = cx.expr_path(cx.path_global(trait_span, + vec![cx.ident_of(krate), + cx.ident_of("Encodable"), + cx.ident_of("encode")])); return match *substr.fields { Struct(_, ref fields) => { let emit_struct_field = cx.ident_of("emit_struct_field"); let mut stmts = Vec::new(); - for (i, &FieldInfo { - name, - ref self_, - span, - .. - }) in fields.iter().enumerate() { + for (i, &FieldInfo { name, ref self_, span, .. }) in fields.iter().enumerate() { let name = match name { Some(id) => id.name.as_str(), - None => { - token::intern_and_get_ident(&format!("_field{}", i)) - } + None => token::intern_and_get_ident(&format!("_field{}", i)), }; let self_ref = cx.expr_addr_of(span, self_.clone()); let enc = cx.expr_call(span, fn_path.clone(), vec![self_ref, blkencoder.clone()]); let lambda = cx.lambda_expr_1(span, enc, blkarg); - let call = cx.expr_method_call(span, blkencoder.clone(), + let call = cx.expr_method_call(span, + blkencoder.clone(), emit_struct_field, - vec!(cx.expr_str(span, name), - cx.expr_usize(span, i), - lambda)); + vec![cx.expr_str(span, name), + cx.expr_usize(span, i), + lambda]); // last call doesn't need a try! let last = fields.len() - 1; @@ -229,11 +225,9 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, cx.expr_method_call(trait_span, encoder, cx.ident_of("emit_struct"), - vec!( - cx.expr_str(trait_span, substr.type_ident.name.as_str()), - cx.expr_usize(trait_span, fields.len()), - blk - )) + vec![cx.expr_str(trait_span, substr.type_ident.name.as_str()), + cx.expr_usize(trait_span, fields.len()), + blk]) } EnumMatching(idx, variant, ref fields) => { @@ -248,14 +242,14 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, if !fields.is_empty() { let last = fields.len() - 1; for (i, &FieldInfo { ref self_, span, .. }) in fields.iter().enumerate() { - let self_ref = cx.expr_addr_of(span, self_.clone()); - let enc = cx.expr_call(span, fn_path.clone(), vec![self_ref, - blkencoder.clone()]); + let self_ref = cx.expr_addr_of(span, self_.clone()); + let enc = + cx.expr_call(span, fn_path.clone(), vec![self_ref, blkencoder.clone()]); let lambda = cx.lambda_expr_1(span, enc, blkarg); - let call = cx.expr_method_call(span, blkencoder.clone(), + let call = cx.expr_method_call(span, + blkencoder.clone(), emit_variant_arg, - vec!(cx.expr_usize(span, i), - lambda)); + vec![cx.expr_usize(span, i), lambda]); let call = if i != last { cx.expr_try(span, call) } else { @@ -271,23 +265,23 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span, let blk = cx.lambda_stmts_1(trait_span, stmts, blkarg); let name = cx.expr_str(trait_span, variant.node.name.name.as_str()); - let call = cx.expr_method_call(trait_span, blkencoder, + let call = cx.expr_method_call(trait_span, + blkencoder, cx.ident_of("emit_enum_variant"), - vec!(name, - cx.expr_usize(trait_span, idx), - cx.expr_usize(trait_span, fields.len()), - blk)); + vec![name, + cx.expr_usize(trait_span, idx), + cx.expr_usize(trait_span, fields.len()), + blk]); let blk = cx.lambda_expr_1(trait_span, call, blkarg); let ret = cx.expr_method_call(trait_span, encoder, cx.ident_of("emit_enum"), - vec!( - cx.expr_str(trait_span, substr.type_ident.name.as_str()), - blk - )); + vec![cx.expr_str(trait_span, + substr.type_ident.name.as_str()), + blk]); cx.expr_block(cx.block(trait_span, vec![me, cx.stmt_expr(ret)])) } - _ => cx.bug("expected Struct or EnumMatching in derive(Encodable)") + _ => cx.bug("expected Struct or EnumMatching in derive(Encodable)"), }; } diff --git a/src/libsyntax_ext/deriving/generic/mod.rs b/src/libsyntax_ext/deriving/generic/mod.rs index f33898109cc57..cd49e7ec9d2c6 100644 --- a/src/libsyntax_ext/deriving/generic/mod.rs +++ b/src/libsyntax_ext/deriving/generic/mod.rs @@ -192,16 +192,16 @@ use std::collections::HashSet; use std::vec; use syntax::abi::Abi; -use syntax::ast::{self, EnumDef, Expr, Ident, Generics, VariantData, BinOpKind, PatKind}; +use syntax::ast::{self, BinOpKind, EnumDef, Expr, Generics, Ident, PatKind, VariantData}; use syntax::attr; use syntax::attr::AttrMetaMethods; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::codemap::{self, respan}; use syntax::util::move_map::MoveMap; -use syntax::parse::token::{keywords, InternedString}; +use syntax::parse::token::{InternedString, keywords}; use syntax::ptr::P; -use syntax_pos::{Span, DUMMY_SP}; +use syntax_pos::{DUMMY_SP, Span}; use errors::Handler; use self::ty::{LifetimeBounds, Path, Ptr, PtrTy, Self_, Ty}; @@ -273,7 +273,7 @@ pub struct Substructure<'a> { pub self_args: &'a [P], /// verbatim access to any other arguments pub nonself_args: &'a [P], - pub fields: &'a SubstructureFields<'a> + pub fields: &'a SubstructureFields<'a>, } /// Summary of the relevant parts of a struct/enum field. @@ -338,14 +338,17 @@ pub type EnumNonMatchCollapsedFunc<'a> = Box]) -> P + 'a>; pub fn combine_substructure<'a>(f: CombineSubstructureFunc<'a>) - -> RefCell> { + -> RefCell> { RefCell::new(f) } /// This method helps to extract all the type parameters referenced from a /// type. For a type parameter ``, it looks for either a `TyPath` that /// is not global and starts with `T`, or a `TyQPath`. -fn find_type_parameters(ty: &ast::Ty, ty_param_names: &[ast::Name], span: Span, cx: &ExtCtxt) +fn find_type_parameters(ty: &ast::Ty, + ty_param_names: &[ast::Name], + span: Span, + cx: &ExtCtxt) -> Vec> { use syntax::visit; @@ -395,23 +398,15 @@ impl<'a> TraitDef<'a> { cx: &mut ExtCtxt, mitem: &ast::MetaItem, item: &'a Annotatable, - push: &mut FnMut(Annotatable)) - { + push: &mut FnMut(Annotatable)) { match *item { Annotatable::Item(ref item) => { let newitem = match item.node { ast::ItemKind::Struct(ref struct_def, ref generics) => { - self.expand_struct_def(cx, - &struct_def, - item.ident, - generics) + self.expand_struct_def(cx, &struct_def, item.ident, generics) } ast::ItemKind::Enum(ref enum_def, ref generics) => { - self.expand_enum_def(cx, - enum_def, - &item.attrs, - item.ident, - generics) + self.expand_enum_def(cx, enum_def, &item.attrs, item.ident, generics) } _ => { cx.span_err(mitem.span, @@ -422,19 +417,20 @@ impl<'a> TraitDef<'a> { // Keep the lint attributes of the previous item to control how the // generated implementations are linted let mut attrs = newitem.attrs.clone(); - attrs.extend(item.attrs.iter().filter(|a| { - match &a.name()[..] { - "allow" | "warn" | "deny" | "forbid" | "stable" | "unstable" => true, - _ => false, - } - }).cloned()); - push(Annotatable::Item(P(ast::Item { - attrs: attrs, - ..(*newitem).clone() - }))) + attrs.extend(item.attrs + .iter() + .filter(|a| { + match &a.name()[..] { + "allow" | "warn" | "deny" | "forbid" | "stable" | "unstable" => true, + _ => false, + } + }) + .cloned()); + push(Annotatable::Item(P(ast::Item { attrs: attrs, ..(*newitem).clone() }))) } _ => { - cx.span_err(mitem.span, "`derive` may only be applied to structs and enums"); + cx.span_err(mitem.span, + "`derive` may only be applied to structs and enums"); } } } @@ -475,7 +471,8 @@ impl<'a> TraitDef<'a> { type_ident: Ident, generics: &Generics, field_tys: Vec>, - methods: Vec) -> P { + methods: Vec) + -> P { let trait_path = self.path.to_path(cx, self.span, type_ident, generics); // Transform associated types from `deriving::ty::Ty` into `ast::ImplItem` @@ -487,16 +484,12 @@ impl<'a> TraitDef<'a> { vis: ast::Visibility::Inherited, defaultness: ast::Defaultness::Final, attrs: Vec::new(), - node: ast::ImplItemKind::Type(type_def.to_ty(cx, - self.span, - type_ident, - generics - )), + node: ast::ImplItemKind::Type(type_def.to_ty(cx, self.span, type_ident, generics)), } }); - let Generics { mut lifetimes, ty_params, mut where_clause } = - self.generics.to_generics(cx, self.span, type_ident, generics); + let Generics { mut lifetimes, ty_params, mut where_clause } = self.generics + .to_generics(cx, self.span, type_ident, generics); let mut ty_params = ty_params.into_vec(); // Copy the lifetimes @@ -521,10 +514,7 @@ impl<'a> TraitDef<'a> { bounds.push((*declared_bound).clone()); } - cx.typaram(self.span, - ty_param.ident, - P::from_vec(bounds), - None) + cx.typaram(self.span, ty_param.ident, P::from_vec(bounds), None) })); // and similarly for where clauses @@ -542,7 +532,7 @@ impl<'a> TraitDef<'a> { ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate { span: self.span, lifetime: rb.lifetime, - bounds: rb.bounds.iter().cloned().collect() + bounds: rb.bounds.iter().cloned().collect(), }) } ast::WherePredicate::EqPredicate(ref we) => { @@ -550,7 +540,7 @@ impl<'a> TraitDef<'a> { id: ast::DUMMY_NODE_ID, span: self.span, path: we.path.clone(), - ty: we.ty.clone() + ty: we.ty.clone(), }) } } @@ -568,16 +558,17 @@ impl<'a> TraitDef<'a> { for ty in tys { // if we have already handled this type, skip it if let ast::TyKind::Path(_, ref p) = ty.node { - if p.segments.len() == 1 - && ty_param_names.contains(&p.segments[0].identifier.name) - || processed_field_types.contains(&p.segments) { + if p.segments.len() == 1 && + ty_param_names.contains(&p.segments[0].identifier.name) || + processed_field_types.contains(&p.segments) { continue; }; processed_field_types.insert(p.segments.clone()); } - let mut bounds: Vec<_> = self.additional_bounds.iter().map(|p| { - cx.typarambound(p.to_path(cx, self.span, type_ident, generics)) - }).collect(); + let mut bounds: Vec<_> = self.additional_bounds + .iter() + .map(|p| cx.typarambound(p.to_path(cx, self.span, type_ident, generics))) + .collect(); // require the current trait bounds.push(cx.typarambound(trait_path.clone())); @@ -598,40 +589,41 @@ impl<'a> TraitDef<'a> { let trait_generics = Generics { lifetimes: lifetimes, ty_params: P::from_vec(ty_params), - where_clause: where_clause + where_clause: where_clause, }; // Create the reference to the trait. let trait_ref = cx.trait_ref(trait_path); // Create the type parameters on the `self` path. - let self_ty_params = generics.ty_params.iter().map(|ty_param| { - cx.ty_ident(self.span, ty_param.ident) - }).collect(); + let self_ty_params = generics.ty_params + .iter() + .map(|ty_param| cx.ty_ident(self.span, ty_param.ident)) + .collect(); - let self_lifetimes: Vec = - generics.lifetimes + let self_lifetimes: Vec = generics.lifetimes .iter() .map(|ld| ld.lifetime) .collect(); // Create the type of `self`. - let self_type = cx.ty_path( - cx.path_all(self.span, false, vec!( type_ident ), self_lifetimes, - self_ty_params, Vec::new())); - - let attr = cx.attribute( - self.span, - cx.meta_word(self.span, - InternedString::new("automatically_derived"))); + let self_type = cx.ty_path(cx.path_all(self.span, + false, + vec![type_ident], + self_lifetimes, + self_ty_params, + Vec::new())); + + let attr = cx.attribute(self.span, + cx.meta_word(self.span, + InternedString::new("automatically_derived"))); // Just mark it now since we know that it'll end up used downstream attr::mark_used(&attr); let opt_trait_ref = Some(trait_ref); - let unused_qual = cx.attribute( - self.span, - cx.meta_list(self.span, - InternedString::new("allow"), - vec![cx.meta_word(self.span, + let unused_qual = cx.attribute(self.span, + cx.meta_list(self.span, + InternedString::new("allow"), + vec![cx.meta_word(self.span, InternedString::new("unused_qualifications"))])); let mut a = vec![attr, unused_qual]; a.extend(self.attributes.iter().cloned()); @@ -642,58 +634,60 @@ impl<'a> TraitDef<'a> { ast::Unsafety::Normal }; - cx.item( - self.span, - keywords::Invalid.ident(), - a, - ast::ItemKind::Impl(unsafety, - ast::ImplPolarity::Positive, - trait_generics, - opt_trait_ref, - self_type, - methods.into_iter().chain(associated_types).collect())) + cx.item(self.span, + keywords::Invalid.ident(), + a, + ast::ItemKind::Impl(unsafety, + ast::ImplPolarity::Positive, + trait_generics, + opt_trait_ref, + self_type, + methods.into_iter().chain(associated_types).collect())) } fn expand_struct_def(&self, cx: &mut ExtCtxt, struct_def: &'a VariantData, type_ident: Ident, - generics: &Generics) -> P { - let field_tys: Vec> = struct_def.fields().iter() + generics: &Generics) + -> P { + let field_tys: Vec> = struct_def.fields() + .iter() .map(|field| field.ty.clone()) .collect(); - let methods = self.methods.iter().map(|method_def| { - let (explicit_self, self_args, nonself_args, tys) = - method_def.split_self_nonself_args( - cx, self, type_ident, generics); - - let body = if method_def.is_static() { - method_def.expand_static_struct_method_body( - cx, - self, - struct_def, - type_ident, - &self_args[..], - &nonself_args[..]) - } else { - method_def.expand_struct_method_body(cx, - self, - struct_def, - type_ident, - &self_args[..], - &nonself_args[..]) - }; - - method_def.create_method(cx, - self, - type_ident, - generics, - Abi::Rust, - explicit_self, - tys, - body) - }).collect(); + let methods = self.methods + .iter() + .map(|method_def| { + let (explicit_self, self_args, nonself_args, tys) = + method_def.split_self_nonself_args(cx, self, type_ident, generics); + + let body = if method_def.is_static() { + method_def.expand_static_struct_method_body(cx, + self, + struct_def, + type_ident, + &self_args[..], + &nonself_args[..]) + } else { + method_def.expand_struct_method_body(cx, + self, + struct_def, + type_ident, + &self_args[..], + &nonself_args[..]) + }; + + method_def.create_method(cx, + self, + type_ident, + generics, + Abi::Rust, + explicit_self, + tys, + body) + }) + .collect(); self.create_derived_impl(cx, type_ident, generics, field_tys, methods) } @@ -703,53 +697,57 @@ impl<'a> TraitDef<'a> { enum_def: &'a EnumDef, type_attrs: &[ast::Attribute], type_ident: Ident, - generics: &Generics) -> P { + generics: &Generics) + -> P { let mut field_tys = Vec::new(); for variant in &enum_def.variants { - field_tys.extend(variant.node.data.fields().iter() + field_tys.extend(variant.node + .data + .fields() + .iter() .map(|field| field.ty.clone())); } - let methods = self.methods.iter().map(|method_def| { - let (explicit_self, self_args, nonself_args, tys) = - method_def.split_self_nonself_args(cx, self, - type_ident, generics); - - let body = if method_def.is_static() { - method_def.expand_static_enum_method_body( - cx, - self, - enum_def, - type_ident, - &self_args[..], - &nonself_args[..]) - } else { - method_def.expand_enum_method_body(cx, - self, - enum_def, - type_attrs, - type_ident, - self_args, - &nonself_args[..]) - }; - - method_def.create_method(cx, - self, - type_ident, - generics, - Abi::Rust, - explicit_self, - tys, - body) - }).collect(); + let methods = self.methods + .iter() + .map(|method_def| { + let (explicit_self, self_args, nonself_args, tys) = + method_def.split_self_nonself_args(cx, self, type_ident, generics); + + let body = if method_def.is_static() { + method_def.expand_static_enum_method_body(cx, + self, + enum_def, + type_ident, + &self_args[..], + &nonself_args[..]) + } else { + method_def.expand_enum_method_body(cx, + self, + enum_def, + type_attrs, + type_ident, + self_args, + &nonself_args[..]) + }; + + method_def.create_method(cx, + self, + type_ident, + generics, + Abi::Rust, + explicit_self, + tys, + body) + }) + .collect(); self.create_derived_impl(cx, type_ident, generics, field_tys, methods) } } -fn find_repr_type_name(diagnostic: &Handler, - type_attrs: &[ast::Attribute]) -> &'static str { +fn find_repr_type_name(diagnostic: &Handler, type_attrs: &[ast::Attribute]) -> &'static str { let mut repr_type_name = "isize"; for a in type_attrs { for r in &attr::find_repr_attrs(diagnostic, a) { @@ -782,13 +780,13 @@ impl<'a> MethodDef<'a> { self_args: &[P], nonself_args: &[P], fields: &SubstructureFields) - -> P { + -> P { let substructure = Substructure { type_ident: type_ident, method_ident: cx.ident_of(self.name), self_args: self_args, nonself_args: nonself_args, - fields: fields + fields: fields, }; let mut f = self.combine_substructure.borrow_mut(); let f: &mut CombineSubstructureFunc = &mut *f; @@ -808,12 +806,13 @@ impl<'a> MethodDef<'a> { self.explicit_self.is_none() } - fn split_self_nonself_args(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef, - type_ident: Ident, - generics: &Generics) - -> (Option, Vec>, Vec>, Vec<(Ident, P)>) { + fn split_self_nonself_args + (&self, + cx: &mut ExtCtxt, + trait_: &TraitDef, + type_ident: Ident, + generics: &Generics) + -> (Option, Vec>, Vec>, Vec<(Ident, P)>) { let mut self_args = Vec::new(); let mut nonself_args = Vec::new(); @@ -839,7 +838,7 @@ impl<'a> MethodDef<'a> { match *ty { // for static methods, just treat any Self // arguments as a normal arg - Self_ if nonstatic => { + Self_ if nonstatic => { self_args.push(arg_expr); } Ptr(ref ty, _) if **ty == Self_ && nonstatic => { @@ -861,18 +860,20 @@ impl<'a> MethodDef<'a> { generics: &Generics, abi: Abi, explicit_self: Option, - arg_types: Vec<(Ident, P)> , - body: P) -> ast::ImplItem { + arg_types: Vec<(Ident, P)>, + body: P) + -> ast::ImplItem { // create the generics that aren't for Self let fn_generics = self.generics.to_generics(cx, trait_.span, type_ident, generics); let args = { let self_args = explicit_self.map(|explicit_self| { - ast::Arg::from_self(explicit_self, respan(trait_.span, keywords::SelfValue.ident())) + ast::Arg::from_self(explicit_self, + respan(trait_.span, keywords::SelfValue.ident())) }); let nonself_args = arg_types.into_iter() - .map(|(name, ty)| cx.arg(trait_.span, name, ty)); + .map(|(name, ty)| cx.arg(trait_.span, name, ty)); self_args.into_iter().chain(nonself_args).collect() }; @@ -897,12 +898,13 @@ impl<'a> MethodDef<'a> { defaultness: ast::Defaultness::Final, ident: method_ident, node: ast::ImplItemKind::Method(ast::MethodSig { - generics: fn_generics, - abi: abi, - unsafety: unsafety, - constness: ast::Constness::NotConst, - decl: fn_decl - }, body_block) + generics: fn_generics, + abi: abi, + unsafety: unsafety, + constness: ast::Constness::NotConst, + decl: fn_decl, + }, + body_block), } } @@ -926,26 +928,24 @@ impl<'a> MethodDef<'a> { /// } /// ``` fn expand_struct_method_body<'b>(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef<'b>, - struct_def: &'b VariantData, - type_ident: Ident, - self_args: &[P], - nonself_args: &[P]) - -> P { + cx: &mut ExtCtxt, + trait_: &TraitDef<'b>, + struct_def: &'b VariantData, + type_ident: Ident, + self_args: &[P], + nonself_args: &[P]) + -> P { let mut raw_fields = Vec::new(); // Vec<[fields of self], // [fields of next Self arg], [etc]> let mut patterns = Vec::new(); for i in 0..self_args.len() { - let struct_path= cx.path(DUMMY_SP, vec!( type_ident )); - let (pat, ident_expr) = - trait_.create_struct_pattern(cx, - struct_path, - struct_def, - &format!("__self_{}", - i), - ast::Mutability::Immutable); + let struct_path = cx.path(DUMMY_SP, vec![type_ident]); + let (pat, ident_expr) = trait_.create_struct_pattern(cx, + struct_path, + struct_def, + &format!("__self_{}", i), + ast::Mutability::Immutable); patterns.push(pat); raw_fields.push(ident_expr); } @@ -954,21 +954,23 @@ impl<'a> MethodDef<'a> { let fields = if !raw_fields.is_empty() { let mut raw_fields = raw_fields.into_iter().map(|v| v.into_iter()); let first_field = raw_fields.next().unwrap(); - let mut other_fields: Vec> - = raw_fields.collect(); + let mut other_fields: Vec> = raw_fields.collect(); first_field.map(|(span, opt_id, field, attrs)| { - FieldInfo { - span: span, - name: opt_id, - self_: field, - other: other_fields.iter_mut().map(|l| { - match l.next().unwrap() { - (_, _, ex, _) => ex - } - }).collect(), - attrs: attrs, - } - }).collect() + FieldInfo { + span: span, + name: opt_id, + self_: field, + other: other_fields.iter_mut() + .map(|l| { + match l.next().unwrap() { + (_, _, ex, _) => ex, + } + }) + .collect(), + attrs: attrs, + } + }) + .collect() } else { cx.span_bug(trait_.span, "no self arguments to non-static method in generic \ @@ -976,20 +978,20 @@ impl<'a> MethodDef<'a> { }; // body of the inner most destructuring match - let mut body = self.call_substructure_method( - cx, - trait_, - type_ident, - self_args, - nonself_args, - &Struct(struct_def, fields)); + let mut body = self.call_substructure_method(cx, + trait_, + type_ident, + self_args, + nonself_args, + &Struct(struct_def, fields)); // make a series of nested matches, to destructure the // structs. This is actually right-to-left, but it shouldn't // matter. for (arg_expr, pat) in self_args.iter().zip(patterns) { - body = cx.expr_match(trait_.span, arg_expr.clone(), - vec!( cx.arm(trait_.span, vec!(pat.clone()), body) )) + body = cx.expr_match(trait_.span, + arg_expr.clone(), + vec![cx.arm(trait_.span, vec![pat.clone()], body)]) } body @@ -1002,13 +1004,14 @@ impl<'a> MethodDef<'a> { type_ident: Ident, self_args: &[P], nonself_args: &[P]) - -> P { + -> P { let summary = trait_.summarise_struct(cx, struct_def); self.call_substructure_method(cx, trait_, type_ident, - self_args, nonself_args, + self_args, + nonself_args, &StaticStruct(struct_def, summary)) } @@ -1042,16 +1045,21 @@ impl<'a> MethodDef<'a> { /// as their results are unused. The point of `__self_vi` and /// `__arg_1_vi` is for `PartialOrd`; see #15503.) fn expand_enum_method_body<'b>(&self, - cx: &mut ExtCtxt, - trait_: &TraitDef<'b>, - enum_def: &'b EnumDef, - type_attrs: &[ast::Attribute], - type_ident: Ident, - self_args: Vec>, - nonself_args: &[P]) - -> P { - self.build_enum_match_tuple( - cx, trait_, enum_def, type_attrs, type_ident, self_args, nonself_args) + cx: &mut ExtCtxt, + trait_: &TraitDef<'b>, + enum_def: &'b EnumDef, + type_attrs: &[ast::Attribute], + type_ident: Ident, + self_args: Vec>, + nonself_args: &[P]) + -> P { + self.build_enum_match_tuple(cx, + trait_, + enum_def, + type_attrs, + type_ident, + self_args, + nonself_args) } @@ -1090,20 +1098,21 @@ impl<'a> MethodDef<'a> { /// ... // catch-all remainder can inspect above variant index values. /// } /// ``` - fn build_enum_match_tuple<'b>( - &self, - cx: &mut ExtCtxt, - trait_: &TraitDef<'b>, - enum_def: &'b EnumDef, - type_attrs: &[ast::Attribute], - type_ident: Ident, - self_args: Vec>, - nonself_args: &[P]) -> P { + fn build_enum_match_tuple<'b>(&self, + cx: &mut ExtCtxt, + trait_: &TraitDef<'b>, + enum_def: &'b EnumDef, + type_attrs: &[ast::Attribute], + type_ident: Ident, + self_args: Vec>, + nonself_args: &[P]) + -> P { let sp = trait_.span; let variants = &enum_def.variants; - let self_arg_names = self_args.iter().enumerate() + let self_arg_names = self_args.iter() + .enumerate() .map(|(arg_count, _self_arg)| { if arg_count == 0 { "__self".to_string() @@ -1114,22 +1123,24 @@ impl<'a> MethodDef<'a> { .collect::>(); let self_arg_idents = self_arg_names.iter() - .map(|name|cx.ident_of(&name[..])) + .map(|name| cx.ident_of(&name[..])) .collect::>(); // The `vi_idents` will be bound, solely in the catch-all, to // a series of let statements mapping each self_arg to an int // value corresponding to its discriminant. let vi_idents: Vec = self_arg_names.iter() - .map(|name| { let vi_suffix = format!("{}_vi", &name[..]); - cx.ident_of(&vi_suffix[..]) }) + .map(|name| { + let vi_suffix = format!("{}_vi", &name[..]); + cx.ident_of(&vi_suffix[..]) + }) .collect::>(); // Builds, via callback to call_substructure_method, the // delegated expression that handles the catch-all case, // using `__variants_tuple` to drive logic if necessary. - let catch_all_substructure = EnumNonMatchingCollapsed( - self_arg_idents, &variants[..], &vi_idents[..]); + let catch_all_substructure = + EnumNonMatchingCollapsed(self_arg_idents, &variants[..], &vi_idents[..]); let first_fieldless = variants.iter().find(|v| v.node.data.fields().is_empty()); @@ -1138,15 +1149,16 @@ impl<'a> MethodDef<'a> { // (Variant2, Variant2, ...) => Body2 // ... // where each tuple has length = self_args.len() - let mut match_arms: Vec = variants.iter().enumerate() + let mut match_arms: Vec = variants.iter() + .enumerate() .filter(|&(_, v)| !(self.unify_fieldless_variants && v.node.data.fields().is_empty())) .map(|(index, variant)| { let mk_self_pat = |cx: &mut ExtCtxt, self_arg_name: &str| { - let (p, idents) = trait_.create_enum_variant_pattern( - cx, type_ident, - variant, - self_arg_name, - ast::Mutability::Immutable); + let (p, idents) = trait_.create_enum_variant_pattern(cx, + type_ident, + variant, + self_arg_name, + ast::Mutability::Immutable); (cx.pat(sp, PatKind::Ref(p, ast::Mutability::Immutable)), idents) }; @@ -1213,24 +1225,29 @@ impl<'a> MethodDef<'a> { // expressions for referencing every field of every // Self arg, assuming all are instances of VariantK. // Build up code associated with such a case. - let substructure = EnumMatching(index, - variant, - field_tuples); - let arm_expr = self.call_substructure_method( - cx, trait_, type_ident, &self_args[..], nonself_args, - &substructure); + let substructure = EnumMatching(index, variant, field_tuples); + let arm_expr = self.call_substructure_method(cx, + trait_, + type_ident, + &self_args[..], + nonself_args, + &substructure); cx.arm(sp, vec![single_pat], arm_expr) - }).collect(); + }) + .collect(); let default = match first_fieldless { Some(v) if self.unify_fieldless_variants => { // We need a default case that handles the fieldless variants. // The index and actual variant aren't meaningful in this case, // so just use whatever - Some(self.call_substructure_method( - cx, trait_, type_ident, &self_args[..], nonself_args, - &EnumMatching(0, v, Vec::new()))) + Some(self.call_substructure_method(cx, + trait_, + type_ident, + &self_args[..], + nonself_args, + &EnumMatching(0, v, Vec::new()))) } _ if variants.len() > 1 && self_args.len() > 1 => { // Since we know that all the arguments will match if we reach @@ -1238,7 +1255,7 @@ impl<'a> MethodDef<'a> { // result of the catch all which should help llvm in optimizing it Some(deriving::call_intrinsic(cx, sp, "unreachable", vec![])) } - _ => None + _ => None, }; if let Some(arm) = default { match_arms.push(cx.arm(sp, vec![cx.pat_wild(sp)], arm)); @@ -1279,20 +1296,17 @@ impl<'a> MethodDef<'a> { // ``` let mut index_let_stmts: Vec = Vec::new(); - //We also build an expression which checks whether all discriminants are equal + // We also build an expression which checks whether all discriminants are equal // discriminant_test = __self0_vi == __self1_vi && __self0_vi == __self2_vi && ... let mut discriminant_test = cx.expr_bool(sp, true); - let target_type_name = - find_repr_type_name(&cx.parse_sess.span_diagnostic, type_attrs); + let target_type_name = find_repr_type_name(&cx.parse_sess.span_diagnostic, type_attrs); let mut first_ident = None; for (&ident, self_arg) in vi_idents.iter().zip(&self_args) { let self_addr = cx.expr_addr_of(sp, self_arg.clone()); - let variant_value = deriving::call_intrinsic(cx, - sp, - "discriminant_value", - vec![self_addr]); + let variant_value = + deriving::call_intrinsic(cx, sp, "discriminant_value", vec![self_addr]); let target_ty = cx.ty_ident(sp, cx.ident_of(target_type_name)); let variant_disr = cx.expr_cast(sp, variant_value, target_ty); @@ -1304,8 +1318,8 @@ impl<'a> MethodDef<'a> { let first_expr = cx.expr_ident(sp, first); let id = cx.expr_ident(sp, ident); let test = cx.expr_binary(sp, BinOpKind::Eq, first_expr, id); - discriminant_test = cx.expr_binary(sp, BinOpKind::And, - discriminant_test, test) + discriminant_test = + cx.expr_binary(sp, BinOpKind::And, discriminant_test, test) } None => { first_ident = Some(ident); @@ -1313,9 +1327,12 @@ impl<'a> MethodDef<'a> { } } - let arm_expr = self.call_substructure_method( - cx, trait_, type_ident, &self_args[..], nonself_args, - &catch_all_substructure); + let arm_expr = self.call_substructure_method(cx, + trait_, + type_ident, + &self_args[..], + nonself_args, + &catch_all_substructure); // Final wrinkle: the self_args are expressions that deref // down to desired l-values, but we cannot actually deref @@ -1325,7 +1342,7 @@ impl<'a> MethodDef<'a> { let borrowed_self_args = self_args.move_map(|self_arg| cx.expr_addr_of(sp, self_arg)); let match_arg = cx.expr(sp, ast::ExprKind::Tup(borrowed_self_args)); - //Lastly we create an expression which branches on all discriminants being equal + // Lastly we create an expression which branches on all discriminants being equal // if discriminant_test { // match (...) { // (Variant1, Variant1, ...) => Body1 @@ -1392,8 +1409,7 @@ impl<'a> MethodDef<'a> { // that needs the feature gate enabled.) deriving::call_intrinsic(cx, sp, "unreachable", vec![]) - } - else { + } else { // Final wrinkle: the self_args are expressions that deref // down to desired l-values, but we cannot actually deref @@ -1413,26 +1429,30 @@ impl<'a> MethodDef<'a> { type_ident: Ident, self_args: &[P], nonself_args: &[P]) - -> P { - let summary = enum_def.variants.iter().map(|v| { - let ident = v.node.name; - let summary = trait_.summarise_struct(cx, &v.node.data); - (ident, v.span, summary) - }).collect(); - self.call_substructure_method(cx, trait_, type_ident, - self_args, nonself_args, + -> P { + let summary = enum_def.variants + .iter() + .map(|v| { + let ident = v.node.name; + let summary = trait_.summarise_struct(cx, &v.node.data); + (ident, v.span, summary) + }) + .collect(); + self.call_substructure_method(cx, + trait_, + type_ident, + self_args, + nonself_args, &StaticEnum(enum_def, summary)) } } // general helper methods. impl<'a> TraitDef<'a> { - fn summarise_struct(&self, - cx: &mut ExtCtxt, - struct_def: &VariantData) -> StaticFields { + fn summarise_struct(&self, cx: &mut ExtCtxt, struct_def: &VariantData) -> StaticFields { let mut named_idents = Vec::new(); let mut just_spans = Vec::new(); - for field in struct_def.fields(){ + for field in struct_def.fields() { let sp = Span { expn_id: self.span.expn_id, ..field.span }; match field.ident { Some(ident) => named_idents.push((ident, sp)), @@ -1441,9 +1461,11 @@ impl<'a> TraitDef<'a> { } match (just_spans.is_empty(), named_idents.is_empty()) { - (false, false) => cx.span_bug(self.span, - "a struct with named and unnamed \ - fields in generic `derive`"), + (false, false) => { + cx.span_bug(self.span, + "a struct with named and unnamed \ + fields in generic `derive`") + } // named fields (_, false) => Named(named_idents), // empty structs @@ -1454,46 +1476,57 @@ impl<'a> TraitDef<'a> { fn create_subpatterns(&self, cx: &mut ExtCtxt, - field_paths: Vec , + field_paths: Vec, mutbl: ast::Mutability) -> Vec> { - field_paths.iter().map(|path| { - cx.pat(path.span, - PatKind::Ident(ast::BindingMode::ByRef(mutbl), (*path).clone(), None)) - }).collect() + field_paths.iter() + .map(|path| { + cx.pat(path.span, + PatKind::Ident(ast::BindingMode::ByRef(mutbl), (*path).clone(), None)) + }) + .collect() } - fn create_struct_pattern(&self, - cx: &mut ExtCtxt, - struct_path: ast::Path, - struct_def: &'a VariantData, - prefix: &str, - mutbl: ast::Mutability) - -> (P, Vec<(Span, Option, - P, - &'a [ast::Attribute])>) { + fn create_struct_pattern + (&self, + cx: &mut ExtCtxt, + struct_path: ast::Path, + struct_def: &'a VariantData, + prefix: &str, + mutbl: ast::Mutability) + -> (P, Vec<(Span, Option, P, &'a [ast::Attribute])>) { let mut paths = Vec::new(); let mut ident_exprs = Vec::new(); for (i, struct_field) in struct_def.fields().iter().enumerate() { let sp = Span { expn_id: self.span.expn_id, ..struct_field.span }; let ident = cx.ident_of(&format!("{}_{}", prefix, i)); - paths.push(codemap::Spanned{span: sp, node: ident}); - let val = cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident))); + paths.push(codemap::Spanned { + span: sp, + node: ident, + }); + let val = cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp, ident))); let val = cx.expr(sp, ast::ExprKind::Paren(val)); ident_exprs.push((sp, struct_field.ident, val, &struct_field.attrs[..])); } let subpats = self.create_subpatterns(cx, paths, mutbl); let pattern = if struct_def.is_struct() { - let field_pats = subpats.into_iter().zip(&ident_exprs).map(|(pat, &(sp, ident, _, _))| { - if ident.is_none() { - cx.span_bug(sp, "a braced struct with unnamed fields in `derive`"); - } - codemap::Spanned { - span: pat.span, - node: ast::FieldPat { ident: ident.unwrap(), pat: pat, is_shorthand: false }, - } - }).collect(); + let field_pats = subpats.into_iter() + .zip(&ident_exprs) + .map(|(pat, &(sp, ident, _, _))| { + if ident.is_none() { + cx.span_bug(sp, "a braced struct with unnamed fields in `derive`"); + } + codemap::Spanned { + span: pat.span, + node: ast::FieldPat { + ident: ident.unwrap(), + pat: pat, + is_shorthand: false, + }, + } + }) + .collect(); cx.pat_struct(self.span, struct_path, field_pats) } else { cx.pat_enum(self.span, struct_path, subpats) @@ -1502,20 +1535,21 @@ impl<'a> TraitDef<'a> { (pattern, ident_exprs) } - fn create_enum_variant_pattern(&self, - cx: &mut ExtCtxt, - enum_ident: ast::Ident, - variant: &'a ast::Variant, - prefix: &str, - mutbl: ast::Mutability) - -> (P, Vec<(Span, Option, P, &'a [ast::Attribute])>) { + fn create_enum_variant_pattern + (&self, + cx: &mut ExtCtxt, + enum_ident: ast::Ident, + variant: &'a ast::Variant, + prefix: &str, + mutbl: ast::Mutability) + -> (P, Vec<(Span, Option, P, &'a [ast::Attribute])>) { let variant_ident = variant.node.name; let variant_path = cx.path(variant.span, vec![enum_ident, variant_ident]); self.create_struct_pattern(cx, variant_path, &variant.node.data, prefix, mutbl) } } -/* helpful premade recipes */ +// helpful premade recipes /// Fold the fields. `use_foldl` controls whether this is done /// left-to-right (`true`) or right-to-left (`false`). @@ -1526,35 +1560,29 @@ pub fn cs_fold(use_foldl: bool, cx: &mut ExtCtxt, trait_span: Span, substructure: &Substructure) - -> P where - F: FnMut(&mut ExtCtxt, Span, P, P, &[P]) -> P, + -> P + where F: FnMut(&mut ExtCtxt, Span, P, P, &[P]) -> P { match *substructure.fields { - EnumMatching(_, _, ref all_fields) | Struct(_, ref all_fields) => { + EnumMatching(_, _, ref all_fields) | + Struct(_, ref all_fields) => { if use_foldl { all_fields.iter().fold(base, |old, field| { - f(cx, - field.span, - old, - field.self_.clone(), - &field.other) + f(cx, field.span, old, field.self_.clone(), &field.other) }) } else { all_fields.iter().rev().fold(base, |old, field| { - f(cx, - field.span, - old, - field.self_.clone(), - &field.other) + f(cx, field.span, old, field.self_.clone(), &field.other) }) } - }, - EnumNonMatchingCollapsed(ref all_args, _, tuple) => - enum_nonmatch_f(cx, trait_span, (&all_args[..], tuple), - substructure.nonself_args), - StaticEnum(..) | StaticStruct(..) => { - cx.span_bug(trait_span, "static function in `derive`") } + EnumNonMatchingCollapsed(ref all_args, _, tuple) => { + enum_nonmatch_f(cx, + trait_span, + (&all_args[..], tuple), + substructure.nonself_args) + } + StaticEnum(..) | StaticStruct(..) => cx.span_bug(trait_span, "static function in `derive`"), } } @@ -1572,29 +1600,34 @@ pub fn cs_same_method(f: F, cx: &mut ExtCtxt, trait_span: Span, substructure: &Substructure) - -> P where - F: FnOnce(&mut ExtCtxt, Span, Vec>) -> P, + -> P + where F: FnOnce(&mut ExtCtxt, Span, Vec>) -> P { match *substructure.fields { - EnumMatching(_, _, ref all_fields) | Struct(_, ref all_fields) => { + EnumMatching(_, _, ref all_fields) | + Struct(_, ref all_fields) => { // call self_n.method(other_1_n, other_2_n, ...) - let called = all_fields.iter().map(|field| { - cx.expr_method_call(field.span, - field.self_.clone(), - substructure.method_ident, - field.other.iter() - .map(|e| cx.expr_addr_of(field.span, e.clone())) - .collect()) - }).collect(); + let called = all_fields.iter() + .map(|field| { + cx.expr_method_call(field.span, + field.self_.clone(), + substructure.method_ident, + field.other + .iter() + .map(|e| cx.expr_addr_of(field.span, e.clone())) + .collect()) + }) + .collect(); f(cx, trait_span, called) - }, - EnumNonMatchingCollapsed(ref all_self_args, _, tuple) => - enum_nonmatch_f(cx, trait_span, (&all_self_args[..], tuple), - substructure.nonself_args), - StaticEnum(..) | StaticStruct(..) => { - cx.span_bug(trait_span, "static function in `derive`") } + EnumNonMatchingCollapsed(ref all_self_args, _, tuple) => { + enum_nonmatch_f(cx, + trait_span, + (&all_self_args[..], tuple), + substructure.nonself_args) + } + StaticEnum(..) | StaticStruct(..) => cx.span_bug(trait_span, "static function in `derive`"), } } @@ -1606,10 +1639,8 @@ pub fn is_type_without_fields(item: &Annotatable) -> bool { ast::ItemKind::Enum(ref enum_def, _) => { enum_def.variants.iter().all(|v| v.node.data.fields().is_empty()) } - ast::ItemKind::Struct(ref variant_data, _) => { - variant_data.fields().is_empty() - } - _ => false + ast::ItemKind::Struct(ref variant_data, _) => variant_data.fields().is_empty(), + _ => false, } } else { false diff --git a/src/libsyntax_ext/deriving/hash.rs b/src/libsyntax_ext/deriving/hash.rs index 0fad96c84ef3d..81c8e7112dbd5 100644 --- a/src/libsyntax_ext/deriving/hash.rs +++ b/src/libsyntax_ext/deriving/hash.rs @@ -12,8 +12,8 @@ use deriving; use deriving::generic::*; use deriving::generic::ty::*; -use syntax::ast::{MetaItem, Expr, Mutability}; -use syntax::ext::base::{ExtCtxt, Annotatable}; +use syntax::ast::{Expr, MetaItem, Mutability}; +use syntax::ext::base::{Annotatable, ExtCtxt}; use syntax::ext::build::AstBuilder; use syntax::ptr::P; use syntax_pos::Span; @@ -22,11 +22,9 @@ pub fn expand_deriving_hash(cx: &mut ExtCtxt, span: Span, mitem: &MetaItem, item: &Annotatable, - push: &mut FnMut(Annotatable)) -{ + push: &mut FnMut(Annotatable)) { - let path = Path::new_(pathvec_std!(cx, core::hash::Hash), None, - vec!(), true); + let path = Path::new_(pathvec_std!(cx, core::hash::Hash), None, vec![], true); let typaram = &*deriving::hygienic_type_parameter(item, "__H"); @@ -38,25 +36,23 @@ pub fn expand_deriving_hash(cx: &mut ExtCtxt, additional_bounds: Vec::new(), generics: LifetimeBounds::empty(), is_unsafe: false, - methods: vec!( - MethodDef { - name: "hash", - generics: LifetimeBounds { - lifetimes: Vec::new(), - bounds: vec![(typaram, - vec![path_std!(cx, core::hash::Hasher)])], - }, - explicit_self: borrowed_explicit_self(), - args: vec!(Ptr(Box::new(Literal(arg)), Borrowed(None, Mutability::Mutable))), - ret_ty: nil_ty(), - attributes: vec![], - is_unsafe: false, - unify_fieldless_variants: true, - combine_substructure: combine_substructure(Box::new(|a, b, c| { - hash_substructure(a, b, c) - })) - } - ), + methods: vec![MethodDef { + name: "hash", + generics: LifetimeBounds { + lifetimes: Vec::new(), + bounds: vec![(typaram, vec![path_std!(cx, core::hash::Hasher)])], + }, + explicit_self: borrowed_explicit_self(), + args: vec![Ptr(Box::new(Literal(arg)), + Borrowed(None, Mutability::Mutable))], + ret_ty: nil_ty(), + attributes: vec![], + is_unsafe: false, + unify_fieldless_variants: true, + combine_substructure: combine_substructure(Box::new(|a, b, c| { + hash_substructure(a, b, c) + })), + }], associated_types: Vec::new(), }; @@ -66,7 +62,10 @@ pub fn expand_deriving_hash(cx: &mut ExtCtxt, fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P { let state_expr = match (substr.nonself_args.len(), substr.nonself_args.get(0)) { (1, Some(o_f)) => o_f, - _ => cx.span_bug(trait_span, "incorrect number of arguments in `derive(Hash)`") + _ => { + cx.span_bug(trait_span, + "incorrect number of arguments in `derive(Hash)`") + } }; let call_hash = |span, thing_expr| { let hash_path = { @@ -75,7 +74,7 @@ fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) cx.expr_path(cx.path_global(span, strs)) }; let ref_thing = cx.expr_addr_of(span, thing_expr); - let expr = cx.expr_call(span, hash_path, vec!(ref_thing, state_expr.clone())); + let expr = cx.expr_call(span, hash_path, vec![ref_thing, state_expr.clone()]); cx.stmt_expr(expr) }; let mut stmts = Vec::new(); @@ -92,7 +91,7 @@ fn hash_substructure(cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) fs } - _ => cx.span_bug(trait_span, "impossible substructure in `derive(Hash)`") + _ => cx.span_bug(trait_span, "impossible substructure in `derive(Hash)`"), }; for &FieldInfo { ref self_, span, .. } in fields { diff --git a/src/libsyntax_ext/deriving/mod.rs b/src/libsyntax_ext/deriving/mod.rs index 169e807366197..80e2a923e5569 100644 --- a/src/libsyntax_ext/deriving/mod.rs +++ b/src/libsyntax_ext/deriving/mod.rs @@ -10,9 +10,9 @@ //! The compiler code necessary to implement the `#[derive]` extensions. -use syntax::ast::{MetaItem, MetaItemKind, self}; +use syntax::ast::{self, MetaItem, MetaItemKind}; use syntax::attr::AttrMetaMethods; -use syntax::ext::base::{ExtCtxt, SyntaxEnv, Annotatable}; +use syntax::ext::base::{Annotatable, ExtCtxt, SyntaxEnv}; use syntax::ext::base::{MultiDecorator, MultiItemDecorator, MultiModifier}; use syntax::ext::build::AstBuilder; use syntax::feature_gate; @@ -123,7 +123,8 @@ fn expand_derive(cx: &mut ExtCtxt, span: Some(titem.span), allow_internal_unstable: true, }, - }), ..titem.span + }), + ..titem.span }; if &tname[..] == "Eq" { @@ -133,8 +134,9 @@ fn expand_derive(cx: &mut ExtCtxt, } // #[derive(Foo, Bar)] expands to #[derive_Foo] #[derive_Bar] - item.attrs.push(cx.attribute(span, cx.meta_word(titem.span, - intern_and_get_ident(&format!("derive_{}", tname))))); + item.attrs.push(cx.attribute(span, + cx.meta_word(titem.span, + intern_and_get_ident(&format!("derive_{}", tname))))); } // RFC #1445. `#[derive(PartialEq, Eq)]` adds a (trusted) @@ -142,18 +144,18 @@ fn expand_derive(cx: &mut ExtCtxt, if let Some(eq_span) = eq_span { if found_partial_eq { let structural_match = intern_and_get_ident("structural_match"); - item.attrs.push(cx.attribute(eq_span, - cx.meta_word(eq_span, - structural_match))); + item.attrs.push(cx.attribute(eq_span, cx.meta_word(eq_span, structural_match))); } } item }) - }, |a| { - cx.span_err(span, "`derive` can only be applied to items"); - a - }); + }, + |a| { + cx.span_err(span, + "`derive` can only be applied to items"); + a + }); debug!("expand_derive: annotatable output = {:?}", annot); annot } @@ -261,8 +263,10 @@ fn warn_if_deprecated(ecx: &mut ExtCtxt, sp: Span, name: &str) { "Decodable" => Some("RustcDecodable"), _ => None, } { - ecx.span_warn(sp, &format!("derive({}) is deprecated in favor of derive({})", - name, replacement)); + ecx.span_warn(sp, + &format!("derive({}) is deprecated in favor of derive({})", + name, + replacement)); } } @@ -275,8 +279,7 @@ fn hygienic_type_parameter(item: &Annotatable, base: &str) -> String { if let Annotatable::Item(ref item) = *item { match item.node { ast::ItemKind::Struct(_, ast::Generics { ref ty_params, .. }) | - ast::ItemKind::Enum(_, ast::Generics { ref ty_params, .. }) => { - + ast::ItemKind::Enum(_, ast::Generics { ref ty_params, .. }) => { for ty in ty_params.iter() { typaram.push_str(&ty.ident.name.as_str()); } @@ -293,7 +296,8 @@ fn hygienic_type_parameter(item: &Annotatable, base: &str) -> String { fn call_intrinsic(cx: &ExtCtxt, span: Span, intrinsic: &str, - args: Vec>) -> P { + args: Vec>) + -> P { let path = cx.std_path(&["intrinsics", intrinsic]); let call = cx.expr_call_global(span, path, args); @@ -301,6 +305,6 @@ fn call_intrinsic(cx: &ExtCtxt, stmts: vec![cx.stmt_expr(call)], id: ast::DUMMY_NODE_ID, rules: ast::BlockCheckMode::Unsafe(ast::CompilerGenerated), - span: span })) + span: span, + })) } -