squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Auto merge of #29647 - goyox86:goyox86/rustfmting-librustc_frontII, r=nrc

Browse source 
Hi Rustaceans!

This is the second take  on running latest rustfmt on librustc_front!

This is the same in https://github.com/rust-lang/rust/pull/29075 but cleaned. All fixups have been applied.

//cc @nrc
This commit is contained in:
bors 2015-11-10 08:38:52 +00:00
commit 4b23a0962d
6 changed files with 192 additions and 196 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

59
src/librustc_front/fold.rs
View file

@ -431,14 +431,16 @@ pub fn noop_fold_foreign_mod<T: Folder>(ForeignMod { abi, items }: ForeignMod,
}
pub fn noop_fold_variant<T: Folder>(v: P<Variant>, fld: &mut T) -> P<Variant> {
v.map(|Spanned {node: Variant_ {name, attrs, data, disr_expr}, span}| Spanned {
node: Variant_ {
name: name,
attrs: fold_attrs(attrs, fld),
data: fld.fold_variant_data(data),
disr_expr: disr_expr.map(|e| fld.fold_expr(e)),
},
span: fld.new_span(span),
v.map(|Spanned { node: Variant_ { name, attrs, data, disr_expr }, span }| {
Spanned {
node: Variant_ {
name: name,
attrs: fold_attrs(attrs, fld),
data: fld.fold_variant_data(data),
disr_expr: disr_expr.map(|e| fld.fold_expr(e)),
},
span: fld.new_span(span),
}
})
}
@ -696,12 +698,14 @@ pub fn noop_fold_where_predicate<T: Folder>(pred: WherePredicate, fld: &mut T) -
pub fn noop_fold_variant_data<T: Folder>(vdata: VariantData, fld: &mut T) -> VariantData {
match vdata {
VariantData::Struct(fields, id) => {
VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id))
VariantData::Struct(fields.move_map(|f| fld.fold_struct_field(f)),
fld.new_id(id))
}
VariantData::Tuple(fields, id) => {
VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)), fld.new_id(id))
VariantData::Tuple(fields.move_map(|f| fld.fold_struct_field(f)),
fld.new_id(id))
}
VariantData::Unit(id) => VariantData::Unit(fld.new_id(id))
VariantData::Unit(id) => VariantData::Unit(fld.new_id(id)),
}
}
@ -740,8 +744,7 @@ pub fn noop_fold_struct_field<T: Folder>(f: StructField, fld: &mut T) -> StructF
pub fn noop_fold_field<T: Folder>(Field { name, expr, span }: Field, folder: &mut T) -> Field {
Field {
name: respan(folder.new_span(name.span),
folder.fold_name(name.node)),
name: respan(folder.new_span(name.span), folder.fold_name(name.node)),
expr: folder.fold_expr(expr),
span: folder.new_span(span),
}
@ -812,8 +815,7 @@ pub fn noop_fold_item_underscore<T: Folder>(i: Item_, folder: &mut T) -> Item_ {
ItemStruct(struct_def, folder.fold_generics(generics))
}
ItemDefaultImpl(unsafety, ref trait_ref) => {
ItemDefaultImpl(unsafety,
folder.fold_trait_ref((*trait_ref).clone()))
ItemDefaultImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone()))
}
ItemImpl(unsafety, polarity, generics, ifce, ty, impl_items) => {
let new_impl_items = impl_items.into_iter()
@ -854,8 +856,7 @@ pub fn noop_fold_trait_item<T: Folder>(i: P<TraitItem>,
attrs: fold_attrs(attrs, folder),
node: match node {
ConstTraitItem(ty, default) => {
ConstTraitItem(folder.fold_ty(ty),
default.map(|x| folder.fold_expr(x)))
ConstTraitItem(folder.fold_ty(ty), default.map(|x| folder.fold_expr(x)))
}
MethodTraitItem(sig, body) => {
MethodTraitItem(noop_fold_method_sig(sig, folder),
@ -883,8 +884,7 @@ pub fn noop_fold_impl_item<T: Folder>(i: P<ImplItem>, folder: &mut T) -> SmallVe
ConstImplItem(folder.fold_ty(ty), folder.fold_expr(expr))
}
MethodImplItem(sig, body) => {
MethodImplItem(noop_fold_method_sig(sig, folder),
folder.fold_block(body))
MethodImplItem(noop_fold_method_sig(sig, folder), folder.fold_block(body))
}
TypeImplItem(ty) => TypeImplItem(folder.fold_ty(ty)),
},
@ -981,8 +981,7 @@ pub fn noop_fold_foreign_item<T: Folder>(ni: P<ForeignItem>, folder: &mut T) ->
attrs: fold_attrs(attrs, folder),
node: match node {
ForeignItemFn(fdec, generics) => {
ForeignItemFn(folder.fold_fn_decl(fdec),
folder.fold_generics(generics))
ForeignItemFn(folder.fold_fn_decl(fdec), folder.fold_generics(generics))
}
ForeignItemStatic(t, m) => {
ForeignItemStatic(folder.fold_ty(t), m)
@ -1074,12 +1073,10 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span }: Expr, folder: &mut T)
}
ExprTup(elts) => ExprTup(elts.move_map(|x| folder.fold_expr(x))),
ExprCall(f, args) => {
ExprCall(folder.fold_expr(f),
args.move_map(|x| folder.fold_expr(x)))
ExprCall(folder.fold_expr(f), args.move_map(|x| folder.fold_expr(x)))
}
ExprMethodCall(name, tps, args) => {
ExprMethodCall(respan(folder.new_span(name.span),
folder.fold_name(name.node)),
ExprMethodCall(respan(folder.new_span(name.span), folder.fold_name(name.node)),
tps.move_map(|x| folder.fold_ty(x)),
args.move_map(|x| folder.fold_expr(x)))
}
@ -1127,13 +1124,11 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span }: Expr, folder: &mut T)
}
ExprField(el, name) => {
ExprField(folder.fold_expr(el),
respan(folder.new_span(name.span),
folder.fold_name(name.node)))
respan(folder.new_span(name.span), folder.fold_name(name.node)))
}
ExprTupField(el, index) => {
ExprTupField(folder.fold_expr(el),
respan(folder.new_span(index.span),
folder.fold_usize(index.node)))
respan(folder.new_span(index.span), folder.fold_usize(index.node)))
}
ExprIndex(el, er) => {
ExprIndex(folder.fold_expr(el), folder.fold_expr(er))
@ -1152,12 +1147,10 @@ pub fn noop_fold_expr<T: Folder>(Expr { id, node, span }: Expr, folder: &mut T)
ExprPath(qself, folder.fold_path(path))
}
ExprBreak(opt_ident) => ExprBreak(opt_ident.map(|label| {
respan(folder.new_span(label.span),
folder.fold_ident(label.node))
respan(folder.new_span(label.span), folder.fold_ident(label.node))
})),
ExprAgain(opt_ident) => ExprAgain(opt_ident.map(|label| {
respan(folder.new_span(label.span),
folder.fold_ident(label.node))
respan(folder.new_span(label.span), folder.fold_ident(label.node))
})),
ExprRet(e) => ExprRet(e.map(|x| folder.fold_expr(x))),
ExprInlineAsm(InlineAsm {

33
src/librustc_front/hir.rs
View file

@ -1062,7 +1062,6 @@ pub type ViewPath = Spanned<ViewPath_>;
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum ViewPath_ {
/// `foo::bar::baz as quux`
///
/// or just
@ -1151,7 +1150,7 @@ impl StructFieldKind {
pub fn visibility(&self) -> Visibility {
match *self {
NamedField(_, vis) | UnnamedField(vis) => vis
NamedField(_, vis) | UnnamedField(vis) => vis,
}
}
}
@ -1183,24 +1182,36 @@ impl VariantData {
}
pub fn id(&self) -> NodeId {
match *self {
VariantData::Struct(_, id) | VariantData::Tuple(_, id) | VariantData::Unit(id) => id
VariantData::Struct(_, id) | VariantData::Tuple(_, id) | VariantData::Unit(id) => id,
}
}
pub fn is_struct(&self) -> bool {
if let VariantData::Struct(..) = *self { true } else { false }
if let VariantData::Struct(..) = *self {
true
} else {
false
}
}
pub fn is_tuple(&self) -> bool {
if let VariantData::Tuple(..) = *self { true } else { false }
if let VariantData::Tuple(..) = *self {
true
} else {
false
}
}
pub fn is_unit(&self) -> bool {
if let VariantData::Unit(..) = *self { true } else { false }
if let VariantData::Unit(..) = *self {
true
} else {
false
}
}
}
/*
FIXME (#3300): Should allow items to be anonymous. Right now
we just use dummy names for anon items.
*/
// FIXME (#3300): Should allow items to be anonymous. Right now
// we just use dummy names for anon items.
/// An item
///
/// The name might be a dummy name in case of anonymous items
@ -1244,7 +1255,7 @@ pub enum Item_ {
// Default trait implementations
///
// `impl Trait for .. {}`
/// `impl Trait for .. {}`
ItemDefaultImpl(Unsafety, TraitRef),
/// An implementation, eg `impl<A> Trait for Foo { .. }`
ItemImpl(Unsafety,

94
src/librustc_front/lowering.rs
View file

@ -114,7 +114,7 @@ impl<'a, 'hir> LoweringContext<'a> {
fn next_id(&self) -> NodeId {
let cached = self.cached_id.get();
if cached == 0 {
return self.id_assigner.next_node_id()
return self.id_assigner.next_node_id();
}
self.cached_id.set(cached + 1);
@ -214,8 +214,7 @@ pub fn lower_ty(_lctx: &LoweringContext, t: &Ty) -> P<hir::Ty> {
TyVec(ref ty) => hir::TyVec(lower_ty(_lctx, ty)),
TyPtr(ref mt) => hir::TyPtr(lower_mt(_lctx, mt)),
TyRptr(ref region, ref mt) => {
hir::TyRptr(lower_opt_lifetime(_lctx, region),
lower_mt(_lctx, mt))
hir::TyRptr(lower_opt_lifetime(_lctx, region), lower_mt(_lctx, mt))
}
TyBareFn(ref f) => {
hir::TyBareFn(P(hir::BareFnTy {
@ -502,13 +501,17 @@ pub fn lower_variant_data(_lctx: &LoweringContext, vdata: &VariantData) -> hir::
match *vdata {
VariantData::Struct(ref fields, id) => {
hir::VariantData::Struct(fields.iter()
.map(|f| lower_struct_field(_lctx, f)).collect(), id)
.map(|f| lower_struct_field(_lctx, f))
.collect(),
id)
}
VariantData::Tuple(ref fields, id) => {
hir::VariantData::Tuple(fields.iter()
.map(|f| lower_struct_field(_lctx, f)).collect(), id)
.map(|f| lower_struct_field(_lctx, f))
.collect(),
id)
}
VariantData::Unit(id) => hir::VariantData::Unit(id)
VariantData::Unit(id) => hir::VariantData::Unit(id),
}
}
@ -676,8 +679,7 @@ pub fn lower_impl_item(_lctx: &LoweringContext, i: &ImplItem) -> P<hir::ImplItem
hir::ConstImplItem(lower_ty(_lctx, ty), lower_expr(_lctx, expr))
}
MethodImplItem(ref sig, ref body) => {
hir::MethodImplItem(lower_method_sig(_lctx, sig),
lower_block(_lctx, body))
hir::MethodImplItem(lower_method_sig(_lctx, sig), lower_block(_lctx, body))
}
TypeImplItem(ref ty) => hir::TypeImplItem(lower_ty(_lctx, ty)),
MacImplItem(..) => panic!("Shouldn't exist any more"),
@ -743,8 +745,7 @@ pub fn lower_foreign_item(_lctx: &LoweringContext, i: &ForeignItem) -> P<hir::Fo
attrs: i.attrs.clone(),
node: match i.node {
ForeignItemFn(ref fdec, ref generics) => {
hir::ForeignItemFn(lower_fn_decl(_lctx, fdec),
lower_generics(_lctx, generics))
hir::ForeignItemFn(lower_fn_decl(_lctx, fdec), lower_generics(_lctx, generics))
}
ForeignItemStatic(ref t, m) => {
hir::ForeignItemStatic(lower_ty(_lctx, t), m)
@ -855,8 +856,9 @@ pub fn lower_pat(_lctx: &LoweringContext, p: &Pat) -> P<hir::Pat> {
}
PatTup(ref elts) => hir::PatTup(elts.iter().map(|x| lower_pat(_lctx, x)).collect()),
PatBox(ref inner) => hir::PatBox(lower_pat(_lctx, inner)),
PatRegion(ref inner, mutbl) => hir::PatRegion(lower_pat(_lctx, inner),
lower_mutability(_lctx, mutbl)),
PatRegion(ref inner, mutbl) => {
hir::PatRegion(lower_pat(_lctx, inner), lower_mutability(_lctx, mutbl))
}
PatRange(ref e1, ref e2) => {
hir::PatRange(lower_expr(_lctx, e1), lower_expr(_lctx, e2))
}
@ -1021,11 +1023,12 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
// InPlace::finalize(place)
// })
let expr = {
let call_move_val_init = hir::StmtSemi(make_call(lctx,
&move_val_init,
vec![expr_ident(lctx, e.span, p_ptr_ident),
pop_unsafe_expr]),
lctx.next_id());
let call_move_val_init =
hir::StmtSemi(make_call(lctx,
&move_val_init,
vec![expr_ident(lctx, e.span, p_ptr_ident),
pop_unsafe_expr]),
lctx.next_id());
let call_move_val_init = respan(e.span, call_move_val_init);
let call = make_call(lctx,
@ -1100,14 +1103,10 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
}
});
hir::ExprIf(lower_expr(lctx, cond),
lower_block(lctx, blk),
else_opt)
hir::ExprIf(lower_expr(lctx, cond), lower_block(lctx, blk), else_opt)
}
ExprWhile(ref cond, ref body, opt_ident) => {
hir::ExprWhile(lower_expr(lctx, cond),
lower_block(lctx, body),
opt_ident)
hir::ExprWhile(lower_expr(lctx, cond), lower_block(lctx, body), opt_ident)
}
ExprLoop(ref body, opt_ident) => {
hir::ExprLoop(lower_block(lctx, body), opt_ident)
@ -1132,8 +1131,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
lower_expr(lctx, er))
}
ExprField(ref el, ident) => {
hir::ExprField(lower_expr(lctx, el),
respan(ident.span, ident.node.name))
hir::ExprField(lower_expr(lctx, el), respan(ident.span, ident.node.name))
}
ExprTupField(ref el, ident) => {
hir::ExprTupField(lower_expr(lctx, el), ident)
@ -1406,10 +1404,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
path_global(e.span, strs)
};
expr_call(lctx,
e.span,
expr_path(lctx, into_iter_path),
vec![head])
expr_call(lctx, e.span, expr_path(lctx, into_iter_path), vec![head])
};
let match_expr = expr_match(lctx,
@ -1428,7 +1423,7 @@ pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
false,
result_ident,
match_expr)],
Some(expr_ident(lctx, e.span, result_ident))))
Some(expr_ident(lctx, e.span, result_ident))));
}
ExprMac(_) => panic!("Shouldn't exist here"),
@ -1525,7 +1520,7 @@ pub fn lower_trait_bound_modifier(_lctx: &LoweringContext,
fn arm(pats: Vec<P<hir::Pat>>, expr: P<hir::Expr>) -> hir::Arm {
hir::Arm {
attrs: vec!(),
attrs: vec![],
pats: pats,
guard: None,
body: expr,
@ -1562,9 +1557,7 @@ fn expr_match(lctx: &LoweringContext,
arms: Vec<hir::Arm>,
source: hir::MatchSource)
-> P<hir::Expr> {
expr(lctx,
span,
hir::ExprMatch(arg, arms, source))
expr(lctx, span, hir::ExprMatch(arg, arms, source))
}
fn expr_block(lctx: &LoweringContext, b: P<hir::Block>) -> P<hir::Expr> {
@ -1626,7 +1619,7 @@ fn block_all(lctx: &LoweringContext,
fn pat_some(lctx: &LoweringContext, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
let some = std_path(lctx, &["option", "Option", "Some"]);
let path = path_global(span, some);
pat_enum(lctx, span, path, vec!(pat))
pat_enum(lctx, span, path, vec![pat])
}
fn pat_none(lctx: &LoweringContext, span: Span) -> P<hir::Pat> {
@ -1675,7 +1668,7 @@ fn pat(lctx: &LoweringContext, span: Span, pat: hir::Pat_) -> P<hir::Pat> {
}
fn path_ident(span: Span, id: Ident) -> hir::Path {
path(span, vec!(id))
path(span, vec![id])
}
fn path(span: Span, strs: Vec<Ident>) -> hir::Path {
@ -1723,7 +1716,7 @@ fn std_path(lctx: &LoweringContext, components: &[&str]) -> Vec<Ident> {
v.push(str_to_ident(s));
}
v.extend(components.iter().map(|s| str_to_ident(s)));
return v
return v;
}
// Given suffix ["b","c","d"], returns path `::std::b::c::d` when
@ -1765,9 +1758,7 @@ mod test {
impl MockAssigner {
fn new() -> MockAssigner {
MockAssigner {
next_id: Cell::new(0),
}
MockAssigner { next_id: Cell::new(0) }
}
}
@ -1787,14 +1778,18 @@ mod test {
expn_id: codemap::NO_EXPANSION,
}
}
fn cfg(&self) -> ast::CrateConfig { Vec::new() }
fn cfg(&self) -> ast::CrateConfig {
Vec::new()
}
fn ident_of(&self, st: &str) -> ast::Ident {
parse::token::str_to_ident(st)
}
fn name_of(&self, st: &str) -> ast::Name {
parse::token::intern(st)
}
fn parse_sess(&self) -> &parse::ParseSess { self }
fn parse_sess(&self) -> &parse::ParseSess {
self
}
}
impl NodeIdAssigner for MockAssigner {
@ -1821,11 +1816,20 @@ mod test {
let cx = parse::ParseSess::new();
let mut assigner = MockAssigner::new();
let ast_if_let = quote_expr!(&cx, if let Some(foo) = baz { bar(foo); });
let ast_if_let = quote_expr!(&cx,
if let Some(foo) = baz {
bar(foo);
});
let ast_if_let = assigner.fold_expr(ast_if_let);
let ast_while_let = quote_expr!(&cx, while let Some(foo) = baz { bar(foo); });
let ast_while_let = quote_expr!(&cx,
while let Some(foo) = baz {
bar(foo);
});
let ast_while_let = assigner.fold_expr(ast_while_let);
let ast_for = quote_expr!(&cx, for i in 0..10 { foo(i); });
let ast_for = quote_expr!(&cx,
for i in 0..10 {
foo(i);
});
let ast_for = assigner.fold_expr(ast_for);
let ast_in = quote_expr!(&cx, in HEAP { foo() });
let ast_in = assigner.fold_expr(ast_in);

145
src/librustc_front/print/pprust.rs
View file

@ -899,18 +899,16 @@ impl<'a> State<'a> {
if !struct_def.is_struct() {
if struct_def.is_tuple() {
try!(self.popen());
try!(self.commasep(Inconsistent,
struct_def.fields(),
|s, field| {
match field.node.kind {
hir::NamedField(..) => panic!("unexpected named field"),
hir::UnnamedField(vis) => {
try!(s.print_visibility(vis));
try!(s.maybe_print_comment(field.span.lo));
s.print_type(&*field.node.ty)
}
}
}));
try!(self.commasep(Inconsistent, struct_def.fields(), |s, field| {
match field.node.kind {
hir::NamedField(..) => panic!("unexpected named field"),
hir::UnnamedField(vis) => {
try!(s.print_visibility(vis));
try!(s.maybe_print_comment(field.span.lo));
s.print_type(&*field.node.ty)
}
}
}));
try!(self.pclose());
}
try!(self.print_where_clause(&generics.where_clause));
@ -1489,44 +1487,37 @@ impl<'a> State<'a> {
try!(self.print_string(&a.asm, a.asm_str_style));
try!(self.word_space(":"));
try!(self.commasep(Inconsistent,
&a.outputs,
|s, &(ref co, ref o, is_rw)| {
match co.slice_shift_char() {
Some(('=', operand)) if is_rw => {
try!(s.print_string(&format!("+{}", operand),
ast::CookedStr))
}
_ => try!(s.print_string(&co, ast::CookedStr)),
}
try!(s.popen());
try!(s.print_expr(&**o));
try!(s.pclose());
Ok(())
}));
try!(self.commasep(Inconsistent, &a.outputs, |s, &(ref co, ref o, is_rw)| {
match co.slice_shift_char() {
Some(('=', operand)) if is_rw => {
try!(s.print_string(&format!("+{}", operand), ast::CookedStr))
}
_ => try!(s.print_string(&co, ast::CookedStr)),
}
try!(s.popen());
try!(s.print_expr(&**o));
try!(s.pclose());
Ok(())
}));
try!(space(&mut self.s));
try!(self.word_space(":"));
try!(self.commasep(Inconsistent,
&a.inputs,
|s, &(ref co, ref o)| {
try!(s.print_string(&co, ast::CookedStr));
try!(s.popen());
try!(s.print_expr(&**o));
try!(s.pclose());
Ok(())
}));
try!(self.commasep(Inconsistent, &a.inputs, |s, &(ref co, ref o)| {
try!(s.print_string(&co, ast::CookedStr));
try!(s.popen());
try!(s.print_expr(&**o));
try!(s.pclose());
Ok(())
}));
try!(space(&mut self.s));
try!(self.word_space(":"));
try!(self.commasep(Inconsistent,
&a.clobbers,
|s, co| {
try!(s.print_string(&co, ast::CookedStr));
Ok(())
}));
try!(self.commasep(Inconsistent, &a.clobbers, |s, co| {
try!(s.print_string(&co, ast::CookedStr));
Ok(())
}));
let mut options = vec!();
let mut options = vec![];
if a.volatile {
options.push("volatile");
}
@ -1540,12 +1531,10 @@ impl<'a> State<'a> {
if !options.is_empty() {
try!(space(&mut self.s));
try!(self.word_space(":"));
try!(self.commasep(Inconsistent,
&*options,
|s, &co| {
try!(s.print_string(co, ast::CookedStr));
Ok(())
}));
try!(self.commasep(Inconsistent, &*options, |s, &co| {
try!(s.print_string(co, ast::CookedStr));
Ok(())
}));
}
try!(self.pclose());
@ -1610,7 +1599,7 @@ impl<'a> State<'a> {
try!(self.maybe_print_comment(path.span.lo));
let mut first = !path.global;
for segment in &path.segments[..path.segments.len()-depth] {
for segment in &path.segments[..path.segments.len() - depth] {
if first {
first = false
} else {
@ -1694,9 +1683,7 @@ impl<'a> State<'a> {
hir::ParenthesizedParameters(ref data) => {
try!(word(&mut self.s, "("));
try!(self.commasep(Inconsistent,
&data.inputs,
|s, ty| s.print_type(&**ty)));
try!(self.commasep(Inconsistent, &data.inputs, |s, ty| s.print_type(&**ty)));
try!(word(&mut self.s, ")"));
match data.output {
@ -1716,8 +1703,8 @@ impl<'a> State<'a> {
pub fn print_pat(&mut self, pat: &hir::Pat) -> io::Result<()> {
try!(self.maybe_print_comment(pat.span.lo));
try!(self.ann.pre(self, NodePat(pat)));
/* Pat isn't normalized, but the beauty of it
is that it doesn't matter */
// Pat isn't normalized, but the beauty of it
// is that it doesn't matter
match pat.node {
hir::PatWild => try!(word(&mut self.s, "_")),
hir::PatIdent(binding_mode, ref path1, ref sub) => {
@ -2066,18 +2053,16 @@ impl<'a> State<'a> {
ints.push(i);
}
try!(self.commasep(Inconsistent,
&ints[..],
|s, &idx| {
if idx < generics.lifetimes.len() {
let lifetime = &generics.lifetimes[idx];
s.print_lifetime_def(lifetime)
} else {
let idx = idx - generics.lifetimes.len();
let param = &generics.ty_params[idx];
s.print_ty_param(param)
}
}));
try!(self.commasep(Inconsistent, &ints[..], |s, &idx| {
if idx < generics.lifetimes.len() {
let lifetime = &generics.lifetimes[idx];
s.print_lifetime_def(lifetime)
} else {
let idx = idx - generics.lifetimes.len();
let param = &generics.ty_params[idx];
s.print_ty_param(param)
}
}));
try!(word(&mut self.s, ">"));
Ok(())
@ -2098,7 +2083,7 @@ impl<'a> State<'a> {
pub fn print_where_clause(&mut self, where_clause: &hir::WhereClause) -> io::Result<()> {
if where_clause.predicates.is_empty() {
return Ok(())
return Ok(());
}
try!(space(&mut self.s));
@ -2170,18 +2155,16 @@ impl<'a> State<'a> {
try!(self.print_path(path, false, 0));
try!(word(&mut self.s, "::{"));
}
try!(self.commasep(Inconsistent,
&segments[..],
|s, w| {
match w.node {
hir::PathListIdent { name, .. } => {
s.print_name(name)
}
hir::PathListMod { .. } => {
word(&mut s.s, "self")
}
}
}));
try!(self.commasep(Inconsistent, &segments[..], |s, w| {
match w.node {
hir::PathListIdent { name, .. } => {
s.print_name(name)
}
hir::PathListMod { .. } => {
word(&mut s.s, "self")
}
}
}));
word(&mut self.s, "}")
}
}
@ -2286,7 +2269,7 @@ impl<'a> State<'a> {
match self.next_comment() {
Some(ref cmnt) => {
if (*cmnt).style != comments::Trailing {
return Ok(())
return Ok(());
}
let span_line = cm.lookup_char_pos(span.hi);
let comment_line = cm.lookup_char_pos((*cmnt).pos);

12
src/librustc_front/util.rs
View file

@ -175,7 +175,7 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O>
fn visit_item(&mut self, item: &Item) {
if !self.pass_through_items {
if self.visited_outermost {
return
return;
} else {
self.visited_outermost = true
}
@ -282,11 +282,11 @@ impl<'a, 'v, O: ast_util::IdVisitingOperation> Visitor<'v> for IdVisitor<'a, O>
}
fn visit_variant_data(&mut self,
struct_def: &VariantData,
_: Name,
_: &hir::Generics,
_: NodeId,
_: Span) {
struct_def: &VariantData,
_: Name,
_: &hir::Generics,
_: NodeId,
_: Span) {
self.operation.visit_id(struct_def.id());
visit::walk_struct_def(self, struct_def);
}

45
src/librustc_front/visit.rs
View file

@ -112,15 +112,22 @@ pub trait Visitor<'v> : Sized {
fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef, m: &'v TraitBoundModifier) {
walk_poly_trait_ref(self, t, m)
}
fn visit_variant_data(&mut self, s: &'v VariantData, _: Name,
_: &'v Generics, _: NodeId, _: Span) {
fn visit_variant_data(&mut self,
s: &'v VariantData,
_: Name,
_: &'v Generics,
_: NodeId,
_: Span) {
walk_struct_def(self, s)
}
fn visit_struct_field(&mut self, s: &'v StructField) {
walk_struct_field(self, s)
}
fn visit_enum_def(&mut self, enum_definition: &'v EnumDef,
generics: &'v Generics, item_id: NodeId, _: Span) {
fn visit_enum_def(&mut self,
enum_definition: &'v EnumDef,
generics: &'v Generics,
item_id: NodeId,
_: Span) {
walk_enum_def(self, enum_definition, generics, item_id)
}
fn visit_variant(&mut self, v: &'v Variant, g: &'v Generics, item_id: NodeId) {
@ -226,9 +233,7 @@ pub fn walk_poly_trait_ref<'v, V>(visitor: &mut V,
_modifier: &'v TraitBoundModifier)
where V: Visitor<'v>
{
walk_list!(visitor,
visit_lifetime_def,
&trait_ref.bound_lifetimes);
walk_list!(visitor, visit_lifetime_def, &trait_ref.bound_lifetimes);
visitor.visit_trait_ref(&trait_ref.trait_ref);
}
@ -298,11 +303,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
ItemDefaultImpl(_, ref trait_ref) => {
visitor.visit_trait_ref(trait_ref)
}
ItemImpl(_, _,
ref type_parameters,
ref opt_trait_reference,
ref typ,
ref impl_items) => {
ItemImpl(_, _, ref type_parameters, ref opt_trait_reference, ref typ, ref impl_items) => {
visitor.visit_generics(type_parameters);
walk_list!(visitor, visit_trait_ref, opt_trait_reference);
visitor.visit_ty(typ);
@ -310,8 +311,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item) {
}
ItemStruct(ref struct_definition, ref generics) => {
visitor.visit_generics(generics);
visitor.visit_variant_data(struct_definition, item.name,
generics, item.id, item.span);
visitor.visit_variant_data(struct_definition, item.name, generics, item.id, item.span);
}
ItemTrait(_, ref generics, ref bounds, ref methods) => {
visitor.visit_generics(generics);
@ -326,7 +326,11 @@ pub fn walk_enum_def<'v, V: Visitor<'v>>(visitor: &mut V,
enum_definition: &'v EnumDef,
generics: &'v Generics,
item_id: NodeId) {
walk_list!(visitor, visit_variant, &enum_definition.variants, generics, item_id);
walk_list!(visitor,
visit_variant,
&enum_definition.variants,
generics,
item_id);
}
pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V,
@ -334,8 +338,11 @@ pub fn walk_variant<'v, V: Visitor<'v>>(visitor: &mut V,
generics: &'v Generics,
item_id: NodeId) {
visitor.visit_name(variant.span, variant.node.name);
visitor.visit_variant_data(&variant.node.data, variant.node.name,
generics, item_id, variant.span);
visitor.visit_variant_data(&variant.node.data,
variant.node.name,
generics,
item_id,
variant.span);
walk_list!(visitor, visit_expr, &variant.node.disr_expr);
walk_list!(visitor, visit_attribute, &variant.node.attrs);
}
@ -357,9 +364,7 @@ pub fn walk_ty<'v, V: Visitor<'v>>(visitor: &mut V, typ: &'v Ty) {
}
TyBareFn(ref function_declaration) => {
walk_fn_decl(visitor, &function_declaration.decl);
walk_list!(visitor,
visit_lifetime_def,
&function_declaration.lifetimes);
walk_list!(visitor, visit_lifetime_def, &function_declaration.lifetimes);
}
TyPath(ref maybe_qself, ref path) => {
if let Some(ref qself) = *maybe_qself {