self.end()
}
+ fn commasep_iter<'it, T: 'it, F, I>(&mut self, b: Breaks, elts: I, mut op: F) -> io::Result<()>
+ where F: FnMut(&mut Self, &T) -> io::Result<()>,
+ I: Iterator<Item=&'it T>,
+ {
+ try!(self.rbox(0, b));
+ let mut first = true;
+ for elt in elts {
+ if first { first = false; } else { try!(self.word_space(",")); }
+ try!(op(self, elt));
+ }
+ self.end()
+ }
fn next_lit(&mut self, pos: BytePos) -> Option<comments::Literal> {
let mut cur_lit = self.cur_cmnt_and_lit().cur_lit;
}
ast::ItemStruct(ref struct_def, ref generics) => {
try!(self.head(&visibility_qualified(item.vis,"struct")));
- try!(self.print_struct(&**struct_def, generics, item.ident, item.span));
+ try!(self.print_struct(&struct_def, generics, item.ident, item.span, true));
}
ast::ItemDefaultImpl(unsafety, ref trait_ref) => {
}
pub fn print_struct(&mut self,
- struct_def: &ast::StructDef,
+ struct_def: &ast::VariantData,
generics: &ast::Generics,
ident: ast::Ident,
- span: codemap::Span) -> io::Result<()> {
+ span: codemap::Span,
+ print_finalizer: bool) -> io::Result<()> {
try!(self.print_ident(ident));
try!(self.print_generics(generics));
- if ast_util::struct_def_is_tuple_like(struct_def) {
- if !struct_def.fields.is_empty() {
+ if !struct_def.is_struct() {
+ if struct_def.is_tuple() {
try!(self.popen());
- try!(self.commasep(
- Inconsistent, &struct_def.fields,
+ try!(self.commasep_iter(
+ Inconsistent, struct_def.fields(),
|s, field| {
match field.node.kind {
ast::NamedField(..) => panic!("unexpected named field"),
try!(self.pclose());
}
try!(self.print_where_clause(&generics.where_clause));
- try!(word(&mut self.s, ";"));
+ if print_finalizer {
+ try!(word(&mut self.s, ";"));
+ }
try!(self.end());
self.end() // close the outer-box
} else {
try!(self.bopen());
try!(self.hardbreak_if_not_bol());
- for field in &struct_def.fields {
+ for field in struct_def.fields() {
match field.node.kind {
ast::UnnamedField(..) => panic!("unexpected unnamed field"),
ast::NamedField(ident, visibility) => {
}
pub fn print_variant(&mut self, v: &ast::Variant) -> io::Result<()> {
- match v.node.kind {
- ast::TupleVariantKind(ref args) => {
- try!(self.print_ident(v.node.name));
- if !args.is_empty() {
- try!(self.popen());
- try!(self.commasep(Consistent,
- &args[..],
- |s, arg| s.print_type(&*arg.ty)));
- try!(self.pclose());
- }
- }
- ast::StructVariantKind(ref struct_def) => {
- try!(self.head(""));
- let generics = ast_util::empty_generics();
- try!(self.print_struct(&**struct_def, &generics, v.node.name, v.span));
- }
- }
+ try!(self.head(""));
+ let generics = ast_util::empty_generics();
+ try!(self.print_struct(&v.node.data, &generics, v.node.name, v.span, false));
match v.node.disr_expr {
Some(ref d) => {
try!(space(&mut self.s));
use ast_util;
use codemap;
use parse::token;
+ use ptr::P;
#[test]
fn test_fun_to_string() {
name: ident,
attrs: Vec::new(),
// making this up as I go.... ?
- kind: ast::TupleVariantKind(Vec::new()),
- id: 0,
+ data: P(ast::VariantData::Unit(ast::DUMMY_NODE_ID)),
disr_expr: None,
});