path: path,
typarams: None,
did: did,
+ is_generic: false,
},
lifetimes: vec![]
}, ast::TraitBoundModifier::None)
}
TraitBound(PolyTrait {
- trait_: ResolvedPath { path: path, typarams: None, did: self.def_id, },
+ trait_: ResolvedPath {
+ path: path,
+ typarams: None,
+ did: self.def_id,
+ is_generic: false,
+ },
lifetimes: late_bounds
}, ast::TraitBoundModifier::None)
}
/// it does not preserve mutability or boxes.
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Debug)]
pub enum Type {
- /// structs/enums/traits (anything that'd be an ast::TyPath)
+ /// structs/enums/traits (most that'd be an ast::TyPath)
ResolvedPath {
path: Path,
typarams: Option<Vec<TyParamBound>>,
did: ast::DefId,
+ /// true if is a `T::Name` path for associated types
+ is_generic: bool,
},
/// For parameterized types, so the consumer of the JSON don't go
/// looking for types which don't exist anywhere.
TyObjectSum(ref lhs, ref bounds) => {
let lhs_ty = lhs.clean(cx);
match lhs_ty {
- ResolvedPath { path, typarams: None, did } => {
- ResolvedPath { path: path, typarams: Some(bounds.clean(cx)), did: did}
+ ResolvedPath { path, typarams: None, did, is_generic } => {
+ ResolvedPath {
+ path: path,
+ typarams: Some(bounds.clean(cx)),
+ did: did,
+ is_generic: is_generic,
+ }
}
_ => {
lhs_ty // shouldn't happen
path: path,
typarams: None,
did: did,
+ is_generic: false,
}
}
ty::ty_trait(box ty::TyTrait { ref principal, ref bounds }) => {
path: path,
typarams: Some(typarams),
did: did,
+ is_generic: false,
}
}
ty::ty_tup(ref t) => Tuple(t.clean(cx)),
None => panic!("unresolved id not in defmap")
};
- match def {
- def::DefSelfTy(..) if path.segments.len() == 1 => {
- return Generic(token::get_name(special_idents::type_self.name).to_string());
- }
+ let is_generic = match def {
def::DefPrimTy(p) => match p {
ast::TyStr => return Primitive(Str),
ast::TyBool => return Primitive(Bool),
ast::TyFloat(ast::TyF32) => return Primitive(F32),
ast::TyFloat(ast::TyF64) => return Primitive(F64),
},
- def::DefTyParam(_, _, _, n) => {
- return Generic(token::get_name(n).to_string())
+ def::DefSelfTy(..) if path.segments.len() == 1 => {
+ return Generic(token::get_name(special_idents::type_self.name).to_string());
}
- _ => {}
+ def::DefSelfTy(..) | def::DefTyParam(..) => true,
+ _ => false,
};
let did = register_def(&*cx, def);
- ResolvedPath { path: path, typarams: None, did: did }
+ ResolvedPath { path: path, typarams: None, did: did, is_generic: is_generic }
}
fn register_def(cx: &DocContext, def: def::Def) -> ast::DefId {
}
}],
},
+ is_generic: false,
}
}
clean::Generic(ref name) => {
f.write_str(name)
}
- clean::ResolvedPath{ did, ref typarams, ref path } => {
- // Paths like Self::Output should be rendered with all segments
- try!(resolved_path(f, did, path, path.segments[0].name == "Self"));
+ clean::ResolvedPath{ did, ref typarams, ref path, is_generic } => {
+ // Paths like T::Output and Self::Output should be rendered with all segments
+ try!(resolved_path(f, did, path, is_generic));
tybounds(f, typarams)
}
clean::Infer => write!(f, "_"),
// "fn index<'a>(&'a self, index: I) -> &'a Self::Output"
fn index<'a>(&'a self, index: I) -> &'a Self::Output;
}
+
+// @has assoc_types/fn.use_output.html
+// @has - '//*[@class="rust fn"]' '-> &T::Output'
+pub fn use_output<T: Index<usize>>(obj: &T, index: usize) -> &T::Output {
+ obj.index(index)
+}
+
+pub trait Feed {
+ type Input;
+}
+
+// @has assoc_types/fn.use_input.html
+// @has - '//*[@class="rust fn"]' 'T::Input'
+pub fn use_input<T: Feed>(_feed: &T, _element: T::Input) { }
+
+// @has assoc_types/fn.cmp_input.html
+// @has - '//*[@class="rust fn"]' 'where T::Input: PartialEq<U::Input>'
+pub fn cmp_input<T: Feed, U: Feed>(a: &T::Input, b: &U::Input) -> bool
+ where T::Input: PartialEq<U::Input>
+{
+ a == b
+}