}
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),
+ }
})
}
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)),
}
}
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),
}
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()
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),
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)),
},
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)
}
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)))
}
}
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))
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 {
#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
pub enum ViewPath_ {
-
/// `foo::bar::baz as quux`
///
/// or just
pub fn visibility(&self) -> Visibility {
match *self {
- NamedField(_, vis) | UnnamedField(vis) => vis
+ NamedField(_, vis) | UnnamedField(vis) => vis,
}
}
}
}
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
// Default trait implementations
///
- // `impl Trait for .. {}`
+ /// `impl Trait for .. {}`
ItemDefaultImpl(Unsafety, TraitRef),
/// An implementation, eg `impl<A> Trait for Foo { .. }`
ItemImpl(Unsafety,
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);
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 {
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),
}
}
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"),
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)
}
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))
}
// 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,
}
});
- 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)
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)
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,
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"),
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,
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> {
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> {
}
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 {
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
impl MockAssigner {
fn new() -> MockAssigner {
- MockAssigner {
- next_id: Cell::new(0),
- }
+ MockAssigner { next_id: Cell::new(0) }
}
}
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 {
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);
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));
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");
}
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());
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 {
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 {
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) => {
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(())
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));
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, "}")
}
}
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);
fn visit_item(&mut self, item: &Item) {
if !self.pass_through_items {
if self.visited_outermost {
- return
+ return;
} else {
self.visited_outermost = true
}
}
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);
}
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) {
_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);
}
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);
}
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);
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,
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);
}
}
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 {
projects / rust.git / commitdiff