global: false,
segments: vec![PathSegment {
name: name.to_string(),
- lifetimes: lifetimes,
- types: types,
+ params: PathParameters::AngleBracketed {
+ lifetimes: lifetimes,
+ types: types,
+ }
}],
}
}
}
#[deriving(Clone, RustcEncodable, RustcDecodable, PartialEq)]
-pub struct PathSegment {
- pub name: String,
- pub lifetimes: Vec<Lifetime>,
- pub types: Vec<Type>,
+pub enum PathParameters {
+ AngleBracketed {
+ lifetimes: Vec<Lifetime>,
+ types: Vec<Type>,
+ },
+ Parenthesized {
+ inputs: Vec<Type>,
+ output: Option<Type>
+ }
}
-impl Clean<PathSegment> for ast::PathSegment {
- fn clean(&self, cx: &DocContext) -> PathSegment {
- let (lifetimes, types) = match self.parameters {
+impl Clean<PathParameters> for ast::PathParameters {
+ fn clean(&self, cx: &DocContext) -> PathParameters {
+ match *self {
ast::AngleBracketedParameters(ref data) => {
- (data.lifetimes.clean(cx), data.types.clean(cx))
+ PathParameters::AngleBracketed {
+ lifetimes: data.lifetimes.clean(cx),
+ types: data.types.clean(cx)
+ }
}
ast::ParenthesizedParameters(ref data) => {
- // FIXME -- rustdoc should be taught about Foo() notation
- let inputs = Tuple(data.inputs.clean(cx));
- let output = data.output.as_ref().map(|t| t.clean(cx)).unwrap_or(Tuple(Vec::new()));
- (Vec::new(), vec![inputs, output])
+ PathParameters::Parenthesized {
+ inputs: data.inputs.clean(cx),
+ output: data.output.clean(cx)
+ }
}
- };
+ }
+ }
+}
+#[deriving(Clone, RustcEncodable, RustcDecodable, PartialEq)]
+pub struct PathSegment {
+ pub name: String,
+ pub params: PathParameters
+}
+
+impl Clean<PathSegment> for ast::PathSegment {
+ fn clean(&self, cx: &DocContext) -> PathSegment {
PathSegment {
name: self.identifier.clean(cx),
- lifetimes: lifetimes,
- types: types,
+ params: self.parameters.clean(cx)
}
}
}
global: false,
segments: vec![PathSegment {
name: name.to_string(),
- lifetimes: vec![],
- types: vec![t.clean(cx)],
+ params: PathParameters::AngleBracketed {
+ lifetimes: vec![],
+ types: vec![t.clean(cx)],
+ }
}],
},
}
}
}
-impl fmt::Show for clean::Path {
+impl fmt::Show for clean::PathParameters {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- if self.global {
- try!(f.write("::".as_bytes()))
- }
-
- for (i, seg) in self.segments.iter().enumerate() {
- if i > 0 {
- try!(f.write("::".as_bytes()))
- }
- try!(f.write(seg.name.as_bytes()));
-
- if seg.lifetimes.len() > 0 || seg.types.len() > 0 {
- try!(f.write("<".as_bytes()));
- let mut comma = false;
- for lifetime in seg.lifetimes.iter() {
- if comma {
- try!(f.write(", ".as_bytes()));
+ match *self {
+ clean::PathParameters::AngleBracketed { ref lifetimes, ref types } => {
+ if lifetimes.len() > 0 || types.len() > 0 {
+ try!(f.write("<".as_bytes()));
+ let mut comma = false;
+ for lifetime in lifetimes.iter() {
+ if comma {
+ try!(f.write(", ".as_bytes()));
+ }
+ comma = true;
+ try!(write!(f, "{}", *lifetime));
}
- comma = true;
- try!(write!(f, "{}", *lifetime));
+ for ty in types.iter() {
+ if comma {
+ try!(f.write(", ".as_bytes()));
+ }
+ comma = true;
+ try!(write!(f, "{}", *ty));
+ }
+ try!(f.write(">".as_bytes()));
}
- for ty in seg.types.iter() {
+ }
+ clean::PathParameters::Parenthesized { ref inputs, ref output } => {
+ try!(f.write("(".as_bytes()));
+ let mut comma = false;
+ for ty in inputs.iter() {
if comma {
try!(f.write(", ".as_bytes()));
}
comma = true;
try!(write!(f, "{}", *ty));
}
- try!(f.write(">".as_bytes()));
+ try!(f.write(")".as_bytes()));
+ if let Some(ref ty) = *output {
+ try!(f.write(" -> ".as_bytes()));
+ try!(write!(f, "{}", ty));
+ }
+ }
+ }
+ Ok(())
+ }
+}
+
+impl fmt::Show for clean::PathSegment {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ try!(f.write(self.name.as_bytes()));
+ write!(f, "{}", self.params)
+ }
+}
+
+impl fmt::Show for clean::Path {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ if self.global {
+ try!(f.write("::".as_bytes()))
+ }
+
+ for (i, seg) in self.segments.iter().enumerate() {
+ if i > 0 {
+ try!(f.write("::".as_bytes()))
}
+ try!(write!(f, "{}", seg));
}
Ok(())
}
G: FnOnce(&render::Cache) -> Option<(Vec<String>, ItemType)>,
{
// The generics will get written to both the title and link
- let mut generics = String::new();
let last = path.segments.last().unwrap();
- if last.lifetimes.len() > 0 || last.types.len() > 0 {
- let mut counter = 0u;
- generics.push_str("<");
- for lifetime in last.lifetimes.iter() {
- if counter > 0 { generics.push_str(", "); }
- counter += 1;
- generics.push_str(format!("{}", *lifetime).as_slice());
- }
- for ty in last.types.iter() {
- if counter > 0 { generics.push_str(", "); }
- counter += 1;
- generics.push_str(format!("{}", *ty).as_slice());
- }
- generics.push_str(">");
- }
+ let generics = format!("{}", last.params);
let loc = CURRENT_LOCATION_KEY.with(|l| l.borrow().clone());
let cache = cache();
global: false,
segments: vec!(clean::PathSegment {
name: self.name.clone(),
- lifetimes: Vec::new(),
- types: Vec::new(),
+ params: clean::PathParameters::AngleBracketed {
+ lifetimes: Vec::new(),
+ types: Vec::new(),
+ }
})
};
resolved_path(f, did, &path, false)