Proc(~ClosureDecl),
/// extern "ABI" fn
BareFunction(~BareFunctionDecl),
- Tuple(Vec<Type> ),
+ Tuple(Vec<Type>),
Vector(~Type),
FixedVector(~Type, ~str),
String,
}
#[deriving(Clone, Encodable, Decodable)]
-pub struct StructField {
- pub type_: Type,
+pub enum StructField {
+ HiddenStructField,
+ TypedStructField(Type),
}
impl Clean<Item> for ast::StructField {
fn clean(&self) -> Item {
let (name, vis) = match self.node.kind {
- ast::NamedField(id, vis) => (Some(id), Some(vis)),
- _ => (None, None)
+ ast::NamedField(id, vis) => (Some(id), vis),
+ ast::UnnamedField(vis) => (None, vis)
};
Item {
name: name.clean(),
attrs: self.node.attrs.clean().move_iter().collect(),
source: self.span.clean(),
- visibility: vis,
+ visibility: Some(vis),
id: self.node.id,
- inner: StructFieldItem(StructField {
- type_: self.node.ty.clean(),
- }),
+ inner: StructFieldItem(TypedStructField(self.node.ty.clean())),
}
}
}
#[deriving(Clone, Encodable, Decodable)]
pub enum VariantKind {
CLikeVariant,
- TupleVariant(Vec<Type> ),
+ TupleVariant(Vec<Type>),
StructVariant(VariantStruct),
}
Some(&s.generics),
s.struct_type,
s.fields.as_slice(),
- s.fields_stripped,
"",
true));
try!(write!(w, "</pre>"));
try!(document(w, it));
+ let mut fields = s.fields.iter().filter(|f| {
+ match f.inner {
+ clean::StructFieldItem(clean::HiddenStructField) => false,
+ clean::StructFieldItem(clean::TypedStructField(..)) => true,
+ _ => false,
+ }
+ }).peekable();
match s.struct_type {
- doctree::Plain if s.fields.len() > 0 => {
+ doctree::Plain if fields.peek().is_some() => {
try!(write!(w, "<h2 class='fields'>Fields</h2>\n<table>"));
- for field in s.fields.iter() {
+ for field in fields {
try!(write!(w, "<tr><td id='structfield.{name}'>\
<code>{name}</code></td><td>",
name = field.name.get_ref().as_slice()));
None,
s.struct_type,
s.fields.as_slice(),
- s.fields_stripped,
" ",
false));
}
clean::VariantItem(ref var) => {
match var.kind {
clean::StructVariant(ref s) => {
+ let mut fields = s.fields.iter().filter(|f| {
+ match f.inner {
+ clean::StructFieldItem(ref t) => match *t {
+ clean::HiddenStructField => false,
+ clean::TypedStructField(..) => true,
+ },
+ _ => false,
+ }
+ });
try!(write!(w, "<h3 class='fields'>Fields</h3>\n
<table>"));
- for field in s.fields.iter() {
+ for field in fields {
try!(write!(w, "<tr><td \
id='variant.{v}.field.{f}'>\
<code>{f}</code></td><td>",
g: Option<&clean::Generics>,
ty: doctree::StructType,
fields: &[clean::Item],
- fields_stripped: bool,
tab: &str,
structhead: bool) -> fmt::Result {
try!(write!(w, "{}{}{}",
match ty {
doctree::Plain => {
try!(write!(w, " \\{\n{}", tab));
+ let mut fields_stripped = false;
for field in fields.iter() {
match field.inner {
- clean::StructFieldItem(ref ty) => {
+ clean::StructFieldItem(clean::HiddenStructField) => {
+ fields_stripped = true;
+ }
+ clean::StructFieldItem(clean::TypedStructField(ref ty)) => {
try!(write!(w, " {}{}: {},\n{}",
VisSpace(field.visibility),
field.name.get_ref().as_slice(),
- ty.type_,
+ *ty,
tab));
}
- _ => unreachable!()
- }
+ _ => unreachable!(),
+ };
}
if fields_stripped {
try!(write!(w, ", "));
}
match field.inner {
- clean::StructFieldItem(ref field) => {
- try!(write!(w, "{}", field.type_));
+ clean::StructFieldItem(clean::HiddenStructField) => {
+ try!(write!(w, "_"))
+ }
+ clean::StructFieldItem(clean::TypedStructField(ref ty)) => {
+ try!(write!(w, "{}{}", VisSpace(field.visibility), *ty))
}
_ => unreachable!()
}