Skip to content

Commit 42fbc2c

Browse files
goyox86goyox86
committed
Rustfmt-ing librustc_front.
1 parent e99a77f commit 42fbc2c

File tree

6 files changed

+173
-175
lines changed

6 files changed

+173
-175
lines changed

‎src/librustc_front/fold.rs

+26-33
Original file line numberDiff line numberDiff line change
@@ -431,14 +431,16 @@ pub fn noop_fold_foreign_mod<T: Folder>(ForeignMod { abi, items }: ForeignMod,
431431
}
432432

433433
pub fn noop_fold_variant<T: Folder>(v: P<Variant>, fld: &mut T) -> P<Variant> {
434-
v.map(|Spanned {node: Variant_ {name, attrs, data, disr_expr}, span}| Spanned {
435-
node: Variant_ {
436-
name: name,
437-
attrs: fold_attrs(attrs, fld),
438-
data: fld.fold_variant_data(data),
439-
disr_expr: disr_expr.map(|e| fld.fold_expr(e)),
440-
},
441-
span: fld.new_span(span),
434+
v.map(|Spanned { node: Variant_ { name, attrs, data, disr_expr }, span }| {
435+
Spanned {
436+
node: Variant_ {
437+
name: name,
438+
attrs: fold_attrs(attrs, fld),
439+
data: fld.fold_variant_data(data),
440+
disr_expr: disr_expr.map(|e| fld.fold_expr(e)),
441+
},
442+
span: fld.new_span(span),
443+
}
442444
})
443445
}
444446

@@ -697,12 +699,14 @@ pub fn noop_fold_struct_def<T: Folder>(struct_def: P<VariantData>, fld: &mut T)
697699
struct_def.map(|vdata| {
698700
match vdata {
699701
VariantData::Struct(fields, id) => {
700-
VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id))
702+
VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)),
703+
fld.new_id(id))
701704
}
702705
VariantData::Tuple(fields, id) => {
703-
VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id))
706+
VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)),
707+
fld.new_id(id))
704708
}
705-
VariantData::Unit(id) => VariantData::Unit(fld.new_id(id))
709+
VariantData::Unit(id) => VariantData::Unit(fld.new_id(id)),
706710
}
707711
})
708712
}
@@ -742,8 +746,7 @@ pub fn noop_fold_struct_field<T: Folder>(f: StructField, fld: &mut T) -> StructF
742746

743747
pub fn noop_fold_field<T: Folder>(Field { name, expr, span }: Field, folder: &mut T) -> Field {
744748
Field {
745-
name: respan(folder.new_span(name.span),
746-
folder.fold_name(name.node)),
749+
name: respan(folder.new_span(name.span), folder.fold_name(name.node)),
747750
expr: folder.fold_expr(expr),
748751
span: folder.new_span(span),
749752
}
@@ -814,8 +817,7 @@ pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
814817
ItemStruct(struct_def, folder.fold_generics(generics))
815818
}
816819
ItemDefaultImpl(unsafety, ref trait_ref) => {
817-
ItemDefaultImpl(unsafety,
818-
folder.fold_trait_ref((*trait_ref).clone()))
820+
ItemDefaultImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone()))
819821
}
820822
ItemImpl(unsafety, polarity, generics, ifce, ty, impl_items) => {
821823
let new_impl_items = impl_items.into_iter()
@@ -856,8 +858,7 @@ pub fn noop_fold_trait_item<T: Folder>(i: P<TraitItem>,
856858
attrs: fold_attrs(attrs, folder),
857859
node: match node {
858860
ConstTraitItem(ty, default) => {
859-
ConstTraitItem(folder.fold_ty(ty),
860-
default.map(|x| folder.fold_expr(x)))
861+
ConstTraitItem(folder.fold_ty(ty), default.map(|x| folder.fold_expr(x)))
861862
}
862863
MethodTraitItem(sig, body) => {
863864
MethodTraitItem(noop_fold_method_sig(sig, folder),
@@ -885,8 +886,7 @@ pub fn noop_fold_impl_item<T: Folder>(i: P<ImplItem>, folder: &mut T) -> SmallVe
885886
ConstImplItem(folder.fold_ty(ty), folder.fold_expr(expr))
886887
}
887888
MethodImplItem(sig, body) => {
888-
MethodImplItem(noop_fold_method_sig(sig, folder),
889-
folder.fold_block(body))
889+
MethodImplItem(noop_fold_method_sig(sig, folder), folder.fold_block(body))
890890
}
891891
TypeImplItem(ty) => TypeImplItem(folder.fold_ty(ty)),
892892
},
@@ -983,8 +983,7 @@ pub fn noop_fold_foreign_item<T: Folder>(ni: P<ForeignItem>, folder: &mut T) ->
983983
attrs: fold_attrs(attrs, folder),
984984
node: match node {
985985
ForeignItemFn(fdec, generics) => {
986-
ForeignItemFn(folder.fold_fn_decl(fdec),
987-
folder.fold_generics(generics))
986+
ForeignItemFn(folder.fold_fn_decl(fdec), folder.fold_generics(generics))
988987
}
989988
ForeignItemStatic(t, m) => {
990989
ForeignItemStatic(folder.fold_ty(t), m)
@@ -1076,12 +1075,10 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span }: Expr, folder: &mut T)
10761075
}
10771076
ExprTup(elts) => ExprTup(elts.move_map(|x| folder.fold_expr(x))),
10781077
ExprCall(f, args) => {
1079-
ExprCall(folder.fold_expr(f),
1080-
args.move_map(|x| folder.fold_expr(x)))
1078+
ExprCall(folder.fold_expr(f), args.move_map(|x| folder.fold_expr(x)))
10811079
}
10821080
ExprMethodCall(name, tps, args) => {
1083-
ExprMethodCall(respan(folder.new_span(name.span),
1084-
folder.fold_name(name.node)),
1081+
ExprMethodCall(respan(folder.new_span(name.span), folder.fold_name(name.node)),
10851082
tps.move_map(|x| folder.fold_ty(x)),
10861083
args.move_map(|x| folder.fold_expr(x)))
10871084
}
@@ -1129,13 +1126,11 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span }: Expr, folder: &mut T)
11291126
}
11301127
ExprField(el, name) => {
11311128
ExprField(folder.fold_expr(el),
1132-
respan(folder.new_span(name.span),
1133-
folder.fold_name(name.node)))
1129+
respan(folder.new_span(name.span), folder.fold_name(name.node)))
11341130
}
11351131
ExprTupField(el, index) => {
11361132
ExprTupField(folder.fold_expr(el),
1137-
respan(folder.new_span(index.span),
1138-
folder.fold_usize(index.node)))
1133+
respan(folder.new_span(index.span), folder.fold_usize(index.node)))
11391134
}
11401135
ExprIndex(el, er) => {
11411136
ExprIndex(folder.fold_expr(el), folder.fold_expr(er))
@@ -1154,12 +1149,10 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span }: Expr, folder: &mut T)
11541149
ExprPath(qself, folder.fold_path(path))
11551150
}
11561151
ExprBreak(opt_ident) => ExprBreak(opt_ident.map(|label| {
1157-
respan(folder.new_span(label.span),
1158-
folder.fold_ident(label.node))
1152+
respan(folder.new_span(label.span), folder.fold_ident(label.node))
11591153
})),
11601154
ExprAgain(opt_ident) => ExprAgain(opt_ident.map(|label| {
1161-
respan(folder.new_span(label.span),
1162-
folder.fold_ident(label.node))
1155+
respan(folder.new_span(label.span), folder.fold_ident(label.node))
11631156
})),
11641157
ExprRet(e) => ExprRet(e.map(|x| folder.fold_expr(x))),
11651158
ExprInlineAsm(InlineAsm {

‎src/librustc_front/hir.rs

+22-8
Original file line numberDiff line numberDiff line change
@@ -1073,7 +1073,6 @@ pub type ViewPath = Spanned<ViewPath_>;
10731073

10741074
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
10751075
pub enum ViewPath_ {
1076-
10771076
/// `foo::bar::baz as quux`
10781077
///
10791078
/// or just
@@ -1185,25 +1184,41 @@ pub type FieldIter<'a> = iter::FlatMap<option::IntoIter<&'a Vec<StructField>>,
11851184

11861185
impl VariantData {
11871186
pub fn fields(&self) -> FieldIter {
1188-
fn vec_iter<T>(v: &Vec<T>) -> slice::Iter<T> { v.iter() }
1187+
fn vec_iter<T>(v: &Vec<T>) -> slice::Iter<T> {
1188+
v.iter()
1189+
}
11891190
match *self {
11901191
VariantData::Struct(ref fields, _) | VariantData::Tuple(ref fields, _) => Some(fields),
11911192
_ => None,
1192-
}.into_iter().flat_map(vec_iter)
1193+
}
1194+
.into_iter()
1195+
.flat_map(vec_iter)
11931196
}
11941197
pub fn id(&self) -> NodeId {
11951198
match *self {
1196-
VariantData::Struct(_, id) | VariantData::Tuple(_, id) | VariantData::Unit(id) => id
1199+
VariantData::Struct(_, id) | VariantData::Tuple(_, id) | VariantData::Unit(id) => id,
11971200
}
11981201
}
11991202
pub fn is_struct(&self) -> bool {
1200-
if let VariantData::Struct(..) = *self { true } else { false }
1203+
if let VariantData::Struct(..) = *self {
1204+
true
1205+
} else {
1206+
false
1207+
}
12011208
}
12021209
pub fn is_tuple(&self) -> bool {
1203-
if let VariantData::Tuple(..) = *self { true } else { false }
1210+
if let VariantData::Tuple(..) = *self {
1211+
true
1212+
} else {
1213+
false
1214+
}
12041215
}
12051216
pub fn is_unit(&self) -> bool {
1206-
if let VariantData::Unit(..) = *self { true } else { false }
1217+
if let VariantData::Unit(..) = *self {
1218+
true
1219+
} else {
1220+
false
1221+
}
12071222
}
12081223
}
12091224

@@ -1254,7 +1269,6 @@ pub enum Item_ {
12541269

12551270
// Default trait implementations
12561271
///
1257-
// `impl Trait for .. {}`
12581272
ItemDefaultImpl(Unsafety, TraitRef),
12591273
/// An implementation, eg `impl<A> Trait for Foo { .. }`
12601274
ItemImpl(Unsafety,

‎src/librustc_front/lowering.rs

+42-39
Original file line numberDiff line numberDiff line change
@@ -214,8 +214,7 @@ pub fn lower_ty(_lctx: &LoweringContext, t: &Ty) -> P<hir::Ty> {
214214
TyVec(ref ty) => hir::TyVec(lower_ty(_lctx, ty)),
215215
TyPtr(ref mt) => hir::TyPtr(lower_mt(_lctx, mt)),
216216
TyRptr(ref region, ref mt) => {
217-
hir::TyRptr(lower_opt_lifetime(_lctx, region),
218-
lower_mt(_lctx, mt))
217+
hir::TyRptr(lower_opt_lifetime(_lctx, region), lower_mt(_lctx, mt))
219218
}
220219
TyBareFn(ref f) => {
221220
hir::TyBareFn(P(hir::BareFnTy {
@@ -502,13 +501,17 @@ pub fn lower_struct_def(_lctx: &LoweringContext, sd: &VariantData) -> P<hir::Var
502501
P(match *sd {
503502
VariantData::Struct(ref fields, id) => {
504503
hir::VariantData::Struct(fields.iter()
505-
.map(|f| lower_struct_field(_lctx, f)).collect(), id)
504+
.map(|f| lower_struct_field(_lctx, f))
505+
.collect(),
506+
id)
506507
}
507508
VariantData::Tuple(ref fields, id) => {
508509
hir::VariantData::Tuple(fields.iter()
509-
.map(|f| lower_struct_field(_lctx, f)).collect(), id)
510+
.map(|f| lower_struct_field(_lctx, f))
511+
.collect(),
512+
id)
510513
}
511-
VariantData::Unit(id) => hir::VariantData::Unit(id)
514+
VariantData::Unit(id) => hir::VariantData::Unit(id),
512515
})
513516
}
514517

@@ -676,8 +679,7 @@ pub fn lower_impl_item(_lctx: &LoweringContext, i: &ImplItem) -> P<hir::ImplItem
676679
hir::ConstImplItem(lower_ty(_lctx, ty), lower_expr(_lctx, expr))
677680
}
678681
MethodImplItem(ref sig, ref body) => {
679-
hir::MethodImplItem(lower_method_sig(_lctx, sig),
680-
lower_block(_lctx, body))
682+
hir::MethodImplItem(lower_method_sig(_lctx, sig), lower_block(_lctx, body))
681683
}
682684
TypeImplItem(ref ty) => hir::TypeImplItem(lower_ty(_lctx, ty)),
683685
MacImplItem(..) => panic!("Shouldn't exist any more"),
@@ -743,8 +745,7 @@ pub fn lower_foreign_item(_lctx: &LoweringContext, i: &ForeignItem) -> P<hir::Fo
743745
attrs: i.attrs.clone(),
744746
node: match i.node {
745747
ForeignItemFn(ref fdec, ref generics) => {
746-
hir::ForeignItemFn(lower_fn_decl(_lctx, fdec),
747-
lower_generics(_lctx, generics))
748+
hir::ForeignItemFn(lower_fn_decl(_lctx, fdec), lower_generics(_lctx, generics))
748749
}
749750
ForeignItemStatic(ref t, m) => {
750751
hir::ForeignItemStatic(lower_ty(_lctx, t), m)
@@ -855,8 +856,8 @@ pub fn lower_pat(_lctx: &LoweringContext, p: &Pat) -> P<hir::Pat> {
855856
}
856857
PatTup(ref elts) => hir::PatTup(elts.iter().map(|x| lower_pat(_lctx, x)).collect()),
857858
PatBox(ref inner) => hir::PatBox(lower_pat(_lctx, inner)),
858-
PatRegion(ref inner, mutbl) => hir::PatRegion(lower_pat(_lctx, inner),
859-
lower_mutability(_lctx, mutbl)),
859+
PatRegion(ref inner, mutbl) =>
860+
hir::PatRegion(lower_pat(_lctx, inner), lower_mutability(_lctx, mutbl)),
860861
PatRange(ref e1, ref e2) => {
861862
hir::PatRange(lower_expr(_lctx, e1), lower_expr(_lctx, e2))
862863
}
@@ -1021,11 +1022,12 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
10211022
// InPlace::finalize(place)
10221023
// })
10231024
let expr = {
1024-
let call_move_val_init = hir::StmtSemi(make_call(lctx,
1025-
&move_val_init,
1026-
vec![expr_ident(lctx, e.span, p_ptr_ident),
1027-
pop_unsafe_expr]),
1028-
lctx.next_id());
1025+
let call_move_val_init =
1026+
hir::StmtSemi(make_call(lctx,
1027+
&move_val_init,
1028+
vec![expr_ident(lctx, e.span, p_ptr_ident),
1029+
pop_unsafe_expr]),
1030+
lctx.next_id());
10291031
let call_move_val_init = respan(e.span, call_move_val_init);
10301032

10311033
let call = make_call(lctx,
@@ -1100,14 +1102,10 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
11001102
}
11011103
});
11021104

1103-
hir::ExprIf(lower_expr(lctx, cond),
1104-
lower_block(lctx, blk),
1105-
else_opt)
1105+
hir::ExprIf(lower_expr(lctx, cond), lower_block(lctx, blk), else_opt)
11061106
}
11071107
ExprWhile(ref cond, ref body, opt_ident) => {
1108-
hir::ExprWhile(lower_expr(lctx, cond),
1109-
lower_block(lctx, body),
1110-
opt_ident)
1108+
hir::ExprWhile(lower_expr(lctx, cond), lower_block(lctx, body), opt_ident)
11111109
}
11121110
ExprLoop(ref body, opt_ident) => {
11131111
hir::ExprLoop(lower_block(lctx, body), opt_ident)
@@ -1132,8 +1130,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
11321130
lower_expr(lctx, er))
11331131
}
11341132
ExprField(ref el, ident) => {
1135-
hir::ExprField(lower_expr(lctx, el),
1136-
respan(ident.span, ident.node.name))
1133+
hir::ExprField(lower_expr(lctx, el), respan(ident.span, ident.node.name))
11371134
}
11381135
ExprTupField(ref el, ident) => {
11391136
hir::ExprTupField(lower_expr(lctx, el), ident)
@@ -1406,10 +1403,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
14061403
path_global(e.span, strs)
14071404
};
14081405

1409-
expr_call(lctx,
1410-
e.span,
1411-
expr_path(lctx, into_iter_path),
1412-
vec![head])
1406+
expr_call(lctx, e.span, expr_path(lctx, into_iter_path), vec![head])
14131407
};
14141408

14151409
let match_expr = expr_match(lctx,
@@ -1569,9 +1563,7 @@ fn expr_match(lctx: &LoweringContext,
15691563
arms: Vec<hir::Arm>,
15701564
source: hir::MatchSource)
15711565
-> P<hir::Expr> {
1572-
expr(lctx,
1573-
span,
1574-
hir::ExprMatch(arg, arms, source))
1566+
expr(lctx, span, hir::ExprMatch(arg, arms, source))
15751567
}
15761568

15771569
fn expr_block(lctx: &LoweringContext, b: P<hir::Block>) -> P<hir::Expr> {
@@ -1772,9 +1764,7 @@ mod test {
17721764

17731765
impl MockAssigner {
17741766
fn new() -> MockAssigner {
1775-
MockAssigner {
1776-
next_id: Cell::new(0),
1777-
}
1767+
MockAssigner { next_id: Cell::new(0) }
17781768
}
17791769
}
17801770

@@ -1794,14 +1784,18 @@ mod test {
17941784
expn_id: codemap::NO_EXPANSION,
17951785
}
17961786
}
1797-
fn cfg(&self) -> ast::CrateConfig { Vec::new() }
1787+
fn cfg(&self) -> ast::CrateConfig {
1788+
Vec::new()
1789+
}
17981790
fn ident_of(&self, st: &str) -> ast::Ident {
17991791
parse::token::str_to_ident(st)
18001792
}
18011793
fn name_of(&self, st: &str) -> ast::Name {
18021794
parse::token::intern(st)
18031795
}
1804-
fn parse_sess(&self) -> &parse::ParseSess { self }
1796+
fn parse_sess(&self) -> &parse::ParseSess {
1797+
self
1798+
}
18051799
}
18061800

18071801
impl NodeIdAssigner for MockAssigner {
@@ -1828,11 +1822,20 @@ mod test {
18281822
let cx = parse::ParseSess::new();
18291823
let mut assigner = MockAssigner::new();
18301824

1831-
let ast_if_let = quote_expr!(&cx, if let Some(foo) = baz { bar(foo); });
1825+
let ast_if_let = quote_expr!(&cx,
1826+
if let Some(foo) = baz {
1827+
bar(foo);
1828+
});
18321829
let ast_if_let = assigner.fold_expr(ast_if_let);
1833-
let ast_while_let = quote_expr!(&cx, while let Some(foo) = baz { bar(foo); });
1830+
let ast_while_let = quote_expr!(&cx,
1831+
while let Some(foo) = baz {
1832+
bar(foo);
1833+
});
18341834
let ast_while_let = assigner.fold_expr(ast_while_let);
1835-
let ast_for = quote_expr!(&cx, for i in 0..10 { foo(i); });
1835+
let ast_for = quote_expr!(&cx,
1836+
for i in 0..10 {
1837+
foo(i);
1838+
});
18361839
let ast_for = assigner.fold_expr(ast_for);
18371840
let ast_in = quote_expr!(&cx, in HEAP { foo() });
18381841
let ast_in = assigner.fold_expr(ast_in);

0 commit comments

Comments
 (0)