src/librustdoc/clean/mod.rs

   1 // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! This module contains the "cleaned" pieces of the AST, and the functions
  12 //! that clean them.
  13
  14 pub use self::ImplMethod::*;
  15 pub use self::Type::*;
  16 pub use self::PrimitiveType::*;
  17 pub use self::TypeKind::*;
  18 pub use self::StructField::*;
  19 pub use self::VariantKind::*;
  20 pub use self::Mutability::*;
  21 pub use self::ViewItemInner::*;
  22 pub use self::ViewPath::*;
  23 pub use self::ItemEnum::*;
  24 pub use self::Attribute::*;
  25 pub use self::TyParamBound::*;
  26 pub use self::SelfTy::*;
  27 pub use self::FunctionRetTy::*;
  28 pub use self::TraitMethod::*;
  29
  30 use syntax;
  31 use syntax::ast;
  32 use syntax::ast_util;
  33 use syntax::ast_util::PostExpansionMethod;
  34 use syntax::attr;
  35 use syntax::attr::{AttributeMethods, AttrMetaMethods};
  36 use syntax::codemap::{DUMMY_SP, Pos, Spanned};
  37 use syntax::parse::token::{self, InternedString, special_idents};
  38 use syntax::ptr::P;
  39
  40 use rustc_trans::back::link;
  41 use rustc::metadata::cstore;
  42 use rustc::metadata::csearch;
  43 use rustc::metadata::decoder;
  44 use rustc::middle::def;
  45 use rustc::middle::subst::{self, ParamSpace, VecPerParamSpace};
  46 use rustc::middle::ty;
  47 use rustc::middle::stability;
  48 use rustc::session::config;
  49
  50 use std::rc::Rc;
  51 use std::u32;
  52 use std::str::Str as StrTrait; // Conflicts with Str variant
  53 use std::path::Path as FsPath; // Conflicts with Path struct
  54
  55 use core::DocContext;
  56 use doctree;
  57 use visit_ast;
  58
  59 /// A stable identifier to the particular version of JSON output.
  60 /// Increment this when the `Crate` and related structures change.
  61 pub static SCHEMA_VERSION: &'static str = "0.8.3";
  62
  63 mod inline;
  64
  65 // extract the stability index for a node from tcx, if possible
  66 fn get_stability(cx: &DocContext, def_id: ast::DefId) -> Option<Stability> {
  67     cx.tcx_opt().and_then(|tcx| stability::lookup(tcx, def_id)).clean(cx)
  68 }
  69
  70 pub trait Clean<T> {
  71     fn clean(&self, cx: &DocContext) -> T;
  72 }
  73
  74 impl<T: Clean<U>, U> Clean<Vec<U>> for Vec<T> {
  75     fn clean(&self, cx: &DocContext) -> Vec<U> {
  76         self.iter().map(|x| x.clean(cx)).collect()
  77     }
  78 }
  79
  80 impl<T: Clean<U>, U> Clean<VecPerParamSpace<U>> for VecPerParamSpace<T> {
  81     fn clean(&self, cx: &DocContext) -> VecPerParamSpace<U> {
  82         self.map(|x| x.clean(cx))
  83     }
  84 }
  85
  86 impl<T: Clean<U>, U> Clean<U> for P<T> {
  87     fn clean(&self, cx: &DocContext) -> U {
  88         (**self).clean(cx)
  89     }
  90 }
  91
  92 impl<T: Clean<U>, U> Clean<U> for Rc<T> {
  93     fn clean(&self, cx: &DocContext) -> U {
  94         (**self).clean(cx)
  95     }
  96 }
  97
  98 impl<T: Clean<U>, U> Clean<Option<U>> for Option<T> {
  99     fn clean(&self, cx: &DocContext) -> Option<U> {
 100         match self {
 101             &None => None,
 102             &Some(ref v) => Some(v.clean(cx))
 103         }
 104     }
 105 }
 106
 107 impl<T, U> Clean<U> for ty::Binder<T> where T: Clean<U> {
 108     fn clean(&self, cx: &DocContext) -> U {
 109         self.0.clean(cx)
 110     }
 111 }
 112
 113 impl<T: Clean<U>, U> Clean<Vec<U>> for syntax::owned_slice::OwnedSlice<T> {
 114     fn clean(&self, cx: &DocContext) -> Vec<U> {
 115         self.iter().map(|x| x.clean(cx)).collect()
 116     }
 117 }
 118
 119 #[derive(Clone, RustcEncodable, RustcDecodable)]
 120 pub struct Crate {
 121     pub name: String,
 122     pub src: FsPath,
 123     pub module: Option<Item>,
 124     pub externs: Vec<(ast::CrateNum, ExternalCrate)>,
 125     pub primitives: Vec<PrimitiveType>,
 126 }
 127
 128 impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> {
 129     fn clean(&self, cx: &DocContext) -> Crate {
 130         let mut externs = Vec::new();
 131         cx.sess().cstore.iter_crate_data(|n, meta| {
 132             externs.push((n, meta.clean(cx)));
 133         });
 134         externs.sort_by(|&(a, _), &(b, _)| a.cmp(&b));
 135
 136         // Figure out the name of this crate
 137         let input = config::Input::File(cx.src.clone());
 138         let name = link::find_crate_name(None, self.attrs.as_slice(), &input);
 139
 140         // Clean the crate, translating the entire libsyntax AST to one that is
 141         // understood by rustdoc.
 142         let mut module = self.module.clean(cx);
 143
 144         // Collect all inner modules which are tagged as implementations of
 145         // primitives.
 146         //
 147         // Note that this loop only searches the top-level items of the crate,
 148         // and this is intentional. If we were to search the entire crate for an
 149         // item tagged with `#[doc(primitive)]` then we we would also have to
 150         // search the entirety of external modules for items tagged
 151         // `#[doc(primitive)]`, which is a pretty inefficient process (decoding
 152         // all that metadata unconditionally).
 153         //
 154         // In order to keep the metadata load under control, the
 155         // `#[doc(primitive)]` feature is explicitly designed to only allow the
 156         // primitive tags to show up as the top level items in a crate.
 157         //
 158         // Also note that this does not attempt to deal with modules tagged
 159         // duplicately for the same primitive. This is handled later on when
 160         // rendering by delegating everything to a hash map.
 161         let mut primitives = Vec::new();
 162         {
 163             let m = match module.inner {
 164                 ModuleItem(ref mut m) => m,
 165                 _ => unreachable!(),
 166             };
 167             let mut tmp = Vec::new();
 168             for child in m.items.iter_mut() {
 169                 match child.inner {
 170                     ModuleItem(..) => {}
 171                     _ => continue,
 172                 }
 173                 let prim = match PrimitiveType::find(child.attrs.as_slice()) {
 174                     Some(prim) => prim,
 175                     None => continue,
 176                 };
 177                 primitives.push(prim);
 178                 tmp.push(Item {
 179                     source: Span::empty(),
 180                     name: Some(prim.to_url_str().to_string()),
 181                     attrs: child.attrs.clone(),
 182                     visibility: Some(ast::Public),
 183                     stability: None,
 184                     def_id: ast_util::local_def(prim.to_node_id()),
 185                     inner: PrimitiveItem(prim),
 186                 });
 187             }
 188             m.items.extend(tmp.into_iter());
 189         }
 190
 191         Crate {
 192             name: name.to_string(),
 193             src: cx.src.clone(),
 194             module: Some(module),
 195             externs: externs,
 196             primitives: primitives,
 197         }
 198     }
 199 }
 200
 201 #[derive(Clone, RustcEncodable, RustcDecodable)]
 202 pub struct ExternalCrate {
 203     pub name: String,
 204     pub attrs: Vec<Attribute>,
 205     pub primitives: Vec<PrimitiveType>,
 206 }
 207
 208 impl Clean<ExternalCrate> for cstore::crate_metadata {
 209     fn clean(&self, cx: &DocContext) -> ExternalCrate {
 210         let mut primitives = Vec::new();
 211         cx.tcx_opt().map(|tcx| {
 212             csearch::each_top_level_item_of_crate(&tcx.sess.cstore,
 213                                                   self.cnum,
 214                                                   |def, _, _| {
 215                 let did = match def {
 216                     decoder::DlDef(def::DefMod(did)) => did,
 217                     _ => return
 218                 };
 219                 let attrs = inline::load_attrs(cx, tcx, did);
 220                 PrimitiveType::find(attrs.as_slice()).map(|prim| primitives.push(prim));
 221             })
 222         });
 223         ExternalCrate {
 224             name: self.name.to_string(),
 225             attrs: decoder::get_crate_attributes(self.data()).clean(cx),
 226             primitives: primitives,
 227         }
 228     }
 229 }
 230
 231 /// Anything with a source location and set of attributes and, optionally, a
 232 /// name. That is, anything that can be documented. This doesn't correspond
 233 /// directly to the AST's concept of an item; it's a strict superset.
 234 #[derive(Clone, RustcEncodable, RustcDecodable)]
 235 pub struct Item {
 236     /// Stringified span
 237     pub source: Span,
 238     /// Not everything has a name. E.g., impls
 239     pub name: Option<String>,
 240     pub attrs: Vec<Attribute> ,
 241     pub inner: ItemEnum,
 242     pub visibility: Option<Visibility>,
 243     pub def_id: ast::DefId,
 244     pub stability: Option<Stability>,
 245 }
 246
 247 impl Item {
 248     /// Finds the `doc` attribute as a List and returns the list of attributes
 249     /// nested inside.
 250     pub fn doc_list<'a>(&'a self) -> Option<&'a [Attribute]> {
 251         for attr in self.attrs.iter() {
 252             match *attr {
 253                 List(ref x, ref list) if "doc" == *x => {
 254                     return Some(list.as_slice());
 255                 }
 256                 _ => {}
 257             }
 258         }
 259         return None;
 260     }
 261
 262     /// Finds the `doc` attribute as a NameValue and returns the corresponding
 263     /// value found.
 264     pub fn doc_value<'a>(&'a self) -> Option<&'a str> {
 265         for attr in self.attrs.iter() {
 266             match *attr {
 267                 NameValue(ref x, ref v) if "doc" == *x => {
 268                     return Some(v.as_slice());
 269                 }
 270                 _ => {}
 271             }
 272         }
 273         return None;
 274     }
 275
 276     pub fn is_hidden_from_doc(&self) -> bool {
 277         match self.doc_list() {
 278             Some(ref l) => {
 279                 for innerattr in l.iter() {
 280                     match *innerattr {
 281                         Word(ref s) if "hidden" == *s => {
 282                             return true
 283                         }
 284                         _ => (),
 285                     }
 286                 }
 287             },
 288             None => ()
 289         }
 290         return false;
 291     }
 292
 293     pub fn is_mod(&self) -> bool {
 294         match self.inner { ModuleItem(..) => true, _ => false }
 295     }
 296     pub fn is_trait(&self) -> bool {
 297         match self.inner { TraitItem(..) => true, _ => false }
 298     }
 299     pub fn is_struct(&self) -> bool {
 300         match self.inner { StructItem(..) => true, _ => false }
 301     }
 302     pub fn is_enum(&self) -> bool {
 303         match self.inner { EnumItem(..) => true, _ => false }
 304     }
 305     pub fn is_fn(&self) -> bool {
 306         match self.inner { FunctionItem(..) => true, _ => false }
 307     }
 308 }
 309
 310 #[derive(Clone, RustcEncodable, RustcDecodable)]
 311 pub enum ItemEnum {
 312     StructItem(Struct),
 313     EnumItem(Enum),
 314     FunctionItem(Function),
 315     ModuleItem(Module),
 316     TypedefItem(Typedef),
 317     StaticItem(Static),
 318     ConstantItem(Constant),
 319     TraitItem(Trait),
 320     ImplItem(Impl),
 321     /// `use` and `extern crate`
 322     ViewItemItem(ViewItem),
 323     /// A method signature only. Used for required methods in traits (ie,
 324     /// non-default-methods).
 325     TyMethodItem(TyMethod),
 326     /// A method with a body.
 327     MethodItem(Method),
 328     StructFieldItem(StructField),
 329     VariantItem(Variant),
 330     /// `fn`s from an extern block
 331     ForeignFunctionItem(Function),
 332     /// `static`s from an extern block
 333     ForeignStaticItem(Static),
 334     MacroItem(Macro),
 335     PrimitiveItem(PrimitiveType),
 336     AssociatedTypeItem(TyParam),
 337 }
 338
 339 #[derive(Clone, RustcEncodable, RustcDecodable)]
 340 pub struct Module {
 341     pub items: Vec<Item>,
 342     pub is_crate: bool,
 343 }
 344
 345 impl Clean<Item> for doctree::Module {
 346     fn clean(&self, cx: &DocContext) -> Item {
 347         let name = if self.name.is_some() {
 348             self.name.unwrap().clean(cx)
 349         } else {
 350             "".to_string()
 351         };
 352         let mut foreigns = Vec::new();
 353         for subforeigns in self.foreigns.clean(cx).into_iter() {
 354             for foreign in subforeigns.into_iter() {
 355                 foreigns.push(foreign)
 356             }
 357         }
 358         let items: Vec<Vec<Item> > = vec!(
 359             self.structs.clean(cx),
 360             self.enums.clean(cx),
 361             self.fns.clean(cx),
 362             foreigns,
 363             self.mods.clean(cx),
 364             self.typedefs.clean(cx),
 365             self.statics.clean(cx),
 366             self.constants.clean(cx),
 367             self.traits.clean(cx),
 368             self.impls.clean(cx),
 369             self.view_items.clean(cx).into_iter()
 370                            .flat_map(|s| s.into_iter()).collect(),
 371             self.macros.clean(cx),
 372         );
 373
 374         // determine if we should display the inner contents or
 375         // the outer `mod` item for the source code.
 376         let whence = {
 377             let cm = cx.sess().codemap();
 378             let outer = cm.lookup_char_pos(self.where_outer.lo);
 379             let inner = cm.lookup_char_pos(self.where_inner.lo);
 380             if outer.file.start_pos == inner.file.start_pos {
 381                 // mod foo { ... }
 382                 self.where_outer
 383             } else {
 384                 // mod foo; (and a separate FileMap for the contents)
 385                 self.where_inner
 386             }
 387         };
 388
 389         Item {
 390             name: Some(name),
 391             attrs: self.attrs.clean(cx),
 392             source: whence.clean(cx),
 393             visibility: self.vis.clean(cx),
 394             stability: self.stab.clean(cx),
 395             def_id: ast_util::local_def(self.id),
 396             inner: ModuleItem(Module {
 397                is_crate: self.is_crate,
 398                items: items.iter()
 399                            .flat_map(|x| x.iter().map(|x| (*x).clone()))
 400                            .collect(),
 401             })
 402         }
 403     }
 404 }
 405
 406 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
 407 pub enum Attribute {
 408     Word(String),
 409     List(String, Vec<Attribute> ),
 410     NameValue(String, String)
 411 }
 412
 413 impl Clean<Attribute> for ast::MetaItem {
 414     fn clean(&self, cx: &DocContext) -> Attribute {
 415         match self.node {
 416             ast::MetaWord(ref s) => Word(s.get().to_string()),
 417             ast::MetaList(ref s, ref l) => {
 418                 List(s.get().to_string(), l.clean(cx))
 419             }
 420             ast::MetaNameValue(ref s, ref v) => {
 421                 NameValue(s.get().to_string(), lit_to_string(v))
 422             }
 423         }
 424     }
 425 }
 426
 427 impl Clean<Attribute> for ast::Attribute {
 428     fn clean(&self, cx: &DocContext) -> Attribute {
 429         self.with_desugared_doc(|a| a.node.value.clean(cx))
 430     }
 431 }
 432
 433 // This is a rough approximation that gets us what we want.
 434 impl attr::AttrMetaMethods for Attribute {
 435     fn name(&self) -> InternedString {
 436         match *self {
 437             Word(ref n) | List(ref n, _) | NameValue(ref n, _) => {
 438                 token::intern_and_get_ident(n.as_slice())
 439             }
 440         }
 441     }
 442
 443     fn value_str(&self) -> Option<InternedString> {
 444         match *self {
 445             NameValue(_, ref v) => {
 446                 Some(token::intern_and_get_ident(v.as_slice()))
 447             }
 448             _ => None,
 449         }
 450     }
 451     fn meta_item_list<'a>(&'a self) -> Option<&'a [P<ast::MetaItem>]> { None }
 452 }
 453 impl<'a> attr::AttrMetaMethods for &'a Attribute {
 454     fn name(&self) -> InternedString { (**self).name() }
 455     fn value_str(&self) -> Option<InternedString> { (**self).value_str() }
 456     fn meta_item_list(&self) -> Option<&[P<ast::MetaItem>]> { None }
 457 }
 458
 459 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
 460 pub struct TyParam {
 461     pub name: String,
 462     pub did: ast::DefId,
 463     pub bounds: Vec<TyParamBound>,
 464     pub default: Option<Type>,
 465 }
 466
 467 impl Clean<TyParam> for ast::TyParam {
 468     fn clean(&self, cx: &DocContext) -> TyParam {
 469         TyParam {
 470             name: self.ident.clean(cx),
 471             did: ast::DefId { krate: ast::LOCAL_CRATE, node: self.id },
 472             bounds: self.bounds.clean(cx),
 473             default: self.default.clean(cx),
 474         }
 475     }
 476 }
 477
 478 impl<'tcx> Clean<TyParam> for ty::TypeParameterDef<'tcx> {
 479     fn clean(&self, cx: &DocContext) -> TyParam {
 480         cx.external_typarams.borrow_mut().as_mut().unwrap()
 481           .insert(self.def_id, self.name.clean(cx));
 482         let bounds = self.bounds.clean(cx);
 483         TyParam {
 484             name: self.name.clean(cx),
 485             did: self.def_id,
 486             bounds: bounds,
 487             default: self.default.clean(cx),
 488         }
 489     }
 490 }
 491
 492 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
 493 pub enum TyParamBound {
 494     RegionBound(Lifetime),
 495     TraitBound(PolyTrait, ast::TraitBoundModifier)
 496 }
 497
 498 impl Clean<TyParamBound> for ast::TyParamBound {
 499     fn clean(&self, cx: &DocContext) -> TyParamBound {
 500         match *self {
 501             ast::RegionTyParamBound(lt) => RegionBound(lt.clean(cx)),
 502             ast::TraitTyParamBound(ref t, modifier) => TraitBound(t.clean(cx), modifier),
 503         }
 504     }
 505 }
 506
 507 impl<'tcx> Clean<(Vec<TyParamBound>, Vec<TypeBinding>)> for ty::ExistentialBounds<'tcx> {
 508     fn clean(&self, cx: &DocContext) -> (Vec<TyParamBound>, Vec<TypeBinding>) {
 509         let mut tp_bounds = vec![];
 510         self.region_bound.clean(cx).map(|b| tp_bounds.push(RegionBound(b)));
 511         for bb in self.builtin_bounds.iter() {
 512             tp_bounds.push(bb.clean(cx));
 513         }
 514
 515         let mut bindings = vec![];
 516         for &ty::Binder(ref pb) in self.projection_bounds.iter() {
 517             bindings.push(TypeBinding {
 518                 name: pb.projection_ty.item_name.clean(cx),
 519                 ty: pb.ty.clean(cx)
 520             });
 521         }
 522
 523         (tp_bounds, bindings)
 524     }
 525 }
 526
 527 fn external_path_params(cx: &DocContext, trait_did: Option<ast::DefId>,
 528                         bindings: Vec<TypeBinding>, substs: &subst::Substs) -> PathParameters {
 529     use rustc::middle::ty::sty;
 530     let lifetimes = substs.regions().get_slice(subst::TypeSpace)
 531                     .iter()
 532                     .filter_map(|v| v.clean(cx))
 533                     .collect();
 534     let types = substs.types.get_slice(subst::TypeSpace).to_vec();
 535
 536     match (trait_did, cx.tcx_opt()) {
 537         // Attempt to sugar an external path like Fn<(A, B,), C> to Fn(A, B) -> C
 538         (Some(did), Some(ref tcx)) if tcx.lang_items.fn_trait_kind(did).is_some() => {
 539             assert_eq!(types.len(), 2);
 540             let inputs = match types[0].sty {
 541                 sty::ty_tup(ref tys) => tys.iter().map(|t| t.clean(cx)).collect(),
 542                 _ => {
 543                     return PathParameters::AngleBracketed {
 544                         lifetimes: lifetimes,
 545                         types: types.clean(cx),
 546                         bindings: bindings
 547                     }
 548                 }
 549             };
 550             let output = match types[1].sty {
 551                 sty::ty_tup(ref v) if v.is_empty() => None, // -> ()
 552                 _ => Some(types[1].clean(cx))
 553             };
 554             PathParameters::Parenthesized {
 555                 inputs: inputs,
 556                 output: output
 557             }
 558         },
 559         (_, _) => {
 560             PathParameters::AngleBracketed {
 561                 lifetimes: lifetimes,
 562                 types: types.clean(cx),
 563                 bindings: bindings
 564             }
 565         }
 566     }
 567 }
 568
 569 // trait_did should be set to a trait's DefId if called on a TraitRef, in order to sugar
 570 // from Fn<(A, B,), C> to Fn(A, B) -> C
 571 fn external_path(cx: &DocContext, name: &str, trait_did: Option<ast::DefId>,
 572                  bindings: Vec<TypeBinding>, substs: &subst::Substs) -> Path {
 573     Path {
 574         global: false,
 575         segments: vec![PathSegment {
 576             name: name.to_string(),
 577             params: external_path_params(cx, trait_did, bindings, substs)
 578         }],
 579     }
 580 }
 581
 582 impl Clean<TyParamBound> for ty::BuiltinBound {
 583     fn clean(&self, cx: &DocContext) -> TyParamBound {
 584         let tcx = match cx.tcx_opt() {
 585             Some(tcx) => tcx,
 586             None => return RegionBound(Lifetime::statik())
 587         };
 588         let empty = subst::Substs::empty();
 589         let (did, path) = match *self {
 590             ty::BoundSend =>
 591                 (tcx.lang_items.send_trait().unwrap(),
 592                  external_path(cx, "Send", None, vec![], &empty)),
 593             ty::BoundSized =>
 594                 (tcx.lang_items.sized_trait().unwrap(),
 595                  external_path(cx, "Sized", None, vec![], &empty)),
 596             ty::BoundCopy =>
 597                 (tcx.lang_items.copy_trait().unwrap(),
 598                  external_path(cx, "Copy", None, vec![], &empty)),
 599             ty::BoundSync =>
 600                 (tcx.lang_items.sync_trait().unwrap(),
 601                  external_path(cx, "Sync", None, vec![], &empty)),
 602         };
 603         let fqn = csearch::get_item_path(tcx, did);
 604         let fqn = fqn.into_iter().map(|i| i.to_string()).collect();
 605         cx.external_paths.borrow_mut().as_mut().unwrap().insert(did,
 606                                                                 (fqn, TypeTrait));
 607         TraitBound(PolyTrait {
 608             trait_: ResolvedPath {
 609                 path: path,
 610                 typarams: None,
 611                 did: did,
 612             },
 613             lifetimes: vec![]
 614         }, ast::TraitBoundModifier::None)
 615     }
 616 }
 617
 618 impl<'tcx> Clean<TyParamBound> for ty::TraitRef<'tcx> {
 619     fn clean(&self, cx: &DocContext) -> TyParamBound {
 620         let tcx = match cx.tcx_opt() {
 621             Some(tcx) => tcx,
 622             None => return RegionBound(Lifetime::statik())
 623         };
 624         let fqn = csearch::get_item_path(tcx, self.def_id);
 625         let fqn = fqn.into_iter().map(|i| i.to_string())
 626                      .collect::<Vec<String>>();
 627         let path = external_path(cx, fqn.last().unwrap().as_slice(),
 628                                  Some(self.def_id), vec![], self.substs);
 629         cx.external_paths.borrow_mut().as_mut().unwrap().insert(self.def_id,
 630                                                             (fqn, TypeTrait));
 631
 632         debug!("ty::TraitRef\n  substs.types(TypeSpace): {:?}\n",
 633                self.substs.types.get_slice(ParamSpace::TypeSpace));
 634
 635         // collect any late bound regions
 636         let mut late_bounds = vec![];
 637         for &ty_s in self.substs.types.get_slice(ParamSpace::TypeSpace).iter() {
 638             use rustc::middle::ty::{Region, sty};
 639             if let sty::ty_tup(ref ts) = ty_s.sty {
 640                 for &ty_s in ts.iter() {
 641                     if let sty::ty_rptr(ref reg, _) = ty_s.sty {
 642                         if let &Region::ReLateBound(_, _) = *reg {
 643                             debug!("  hit an ReLateBound {:?}", reg);
 644                             if let Some(lt) = reg.clean(cx) {
 645                                 late_bounds.push(lt)
 646                             }
 647                         }
 648                     }
 649                 }
 650             }
 651         }
 652
 653         TraitBound(PolyTrait {
 654             trait_: ResolvedPath { path: path, typarams: None, did: self.def_id, },
 655             lifetimes: late_bounds
 656         }, ast::TraitBoundModifier::None)
 657     }
 658 }
 659
 660 impl<'tcx> Clean<Vec<TyParamBound>> for ty::ParamBounds<'tcx> {
 661     fn clean(&self, cx: &DocContext) -> Vec<TyParamBound> {
 662         let mut v = Vec::new();
 663         for t in self.trait_bounds.iter() {
 664             v.push(t.clean(cx));
 665         }
 666         for r in self.region_bounds.iter().filter_map(|r| r.clean(cx)) {
 667             v.push(RegionBound(r));
 668         }
 669         v
 670     }
 671 }
 672
 673 impl<'tcx> Clean<Option<Vec<TyParamBound>>> for subst::Substs<'tcx> {
 674     fn clean(&self, cx: &DocContext) -> Option<Vec<TyParamBound>> {
 675         let mut v = Vec::new();
 676         v.extend(self.regions().iter().filter_map(|r| r.clean(cx)).map(RegionBound));
 677         v.extend(self.types.iter().map(|t| TraitBound(PolyTrait {
 678             trait_: t.clean(cx),
 679             lifetimes: vec![]
 680         }, ast::TraitBoundModifier::None)));
 681         if v.len() > 0 {Some(v)} else {None}
 682     }
 683 }
 684
 685 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
 686 pub struct Lifetime(String);
 687
 688 impl Lifetime {
 689     pub fn get_ref<'a>(&'a self) -> &'a str {
 690         let Lifetime(ref s) = *self;
 691         let s: &'a str = s.as_slice();
 692         return s;
 693     }
 694
 695     pub fn statik() -> Lifetime {
 696         Lifetime("'static".to_string())
 697     }
 698 }
 699
 700 impl Clean<Lifetime> for ast::Lifetime {
 701     fn clean(&self, _: &DocContext) -> Lifetime {
 702         Lifetime(token::get_name(self.name).get().to_string())
 703     }
 704 }
 705
 706 impl Clean<Lifetime> for ast::LifetimeDef {
 707     fn clean(&self, _: &DocContext) -> Lifetime {
 708         Lifetime(token::get_name(self.lifetime.name).get().to_string())
 709     }
 710 }
 711
 712 impl Clean<Lifetime> for ty::RegionParameterDef {
 713     fn clean(&self, _: &DocContext) -> Lifetime {
 714         Lifetime(token::get_name(self.name).get().to_string())
 715     }
 716 }
 717
 718 impl Clean<Option<Lifetime>> for ty::Region {
 719     fn clean(&self, cx: &DocContext) -> Option<Lifetime> {
 720         match *self {
 721             ty::ReStatic => Some(Lifetime::statik()),
 722             ty::ReLateBound(_, ty::BrNamed(_, name)) =>
 723                 Some(Lifetime(token::get_name(name).get().to_string())),
 724             ty::ReEarlyBound(_, _, _, name) => Some(Lifetime(name.clean(cx))),
 725
 726             ty::ReLateBound(..) |
 727             ty::ReFree(..) |
 728             ty::ReScope(..) |
 729             ty::ReInfer(..) |
 730             ty::ReEmpty(..) => None
 731         }
 732     }
 733 }
 734
 735 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
 736 pub enum WherePredicate {
 737     BoundPredicate { ty: Type, bounds: Vec<TyParamBound> },
 738     RegionPredicate { lifetime: Lifetime, bounds: Vec<Lifetime>},
 739     EqPredicate { lhs: Type, rhs: Type }
 740 }
 741
 742 impl Clean<WherePredicate> for ast::WherePredicate {
 743     fn clean(&self, cx: &DocContext) -> WherePredicate {
 744         match *self {
 745             ast::WherePredicate::BoundPredicate(ref wbp) => {
 746                 WherePredicate::BoundPredicate {
 747                     ty: wbp.bounded_ty.clean(cx),
 748                     bounds: wbp.bounds.clean(cx)
 749                 }
 750             }
 751
 752             ast::WherePredicate::RegionPredicate(ref wrp) => {
 753                 WherePredicate::RegionPredicate {
 754                     lifetime: wrp.lifetime.clean(cx),
 755                     bounds: wrp.bounds.clean(cx)
 756                 }
 757             }
 758
 759             ast::WherePredicate::EqPredicate(_) => {
 760                 unimplemented!() // FIXME(#20041)
 761             }
 762         }
 763     }
 764 }
 765
 766 impl<'a> Clean<WherePredicate> for ty::Predicate<'a> {
 767     fn clean(&self, cx: &DocContext) -> WherePredicate {
 768         use rustc::middle::ty::Predicate;
 769
 770         match *self {
 771             Predicate::Trait(ref pred) => pred.clean(cx),
 772             Predicate::Equate(ref pred) => pred.clean(cx),
 773             Predicate::RegionOutlives(ref pred) => pred.clean(cx),
 774             Predicate::TypeOutlives(ref pred) => pred.clean(cx),
 775             Predicate::Projection(ref pred) => pred.clean(cx)
 776         }
 777     }
 778 }
 779
 780 impl<'a> Clean<WherePredicate> for ty::TraitPredicate<'a> {
 781     fn clean(&self, cx: &DocContext) -> WherePredicate {
 782         WherePredicate::BoundPredicate {
 783             ty: self.trait_ref.substs.self_ty().clean(cx).unwrap(),
 784             bounds: vec![self.trait_ref.clean(cx)]
 785         }
 786     }
 787 }
 788
 789 impl<'tcx> Clean<WherePredicate> for ty::EquatePredicate<'tcx> {
 790     fn clean(&self, cx: &DocContext) -> WherePredicate {
 791         let ty::EquatePredicate(ref lhs, ref rhs) = *self;
 792         WherePredicate::EqPredicate {
 793             lhs: lhs.clean(cx),
 794             rhs: rhs.clean(cx)
 795         }
 796     }
 797 }
 798
 799 impl Clean<WherePredicate> for ty::OutlivesPredicate<ty::Region, ty::Region> {
 800     fn clean(&self, cx: &DocContext) -> WherePredicate {
 801         let ty::OutlivesPredicate(ref a, ref b) = *self;
 802         WherePredicate::RegionPredicate {
 803             lifetime: a.clean(cx).unwrap(),
 804             bounds: vec![b.clean(cx).unwrap()]
 805         }
 806     }
 807 }
 808
 809 impl<'tcx> Clean<WherePredicate> for ty::OutlivesPredicate<ty::Ty<'tcx>, ty::Region> {
 810     fn clean(&self, cx: &DocContext) -> WherePredicate {
 811         let ty::OutlivesPredicate(ref ty, ref lt) = *self;
 812
 813         WherePredicate::BoundPredicate {
 814             ty: ty.clean(cx),
 815             bounds: vec![TyParamBound::RegionBound(lt.clean(cx).unwrap())]
 816         }
 817     }
 818 }
 819
 820 impl<'tcx> Clean<WherePredicate> for ty::ProjectionPredicate<'tcx> {
 821     fn clean(&self, cx: &DocContext) -> WherePredicate {
 822         WherePredicate::EqPredicate {
 823             lhs: self.projection_ty.clean(cx),
 824             rhs: self.ty.clean(cx)
 825         }
 826     }
 827 }
 828
 829 impl<'tcx> Clean<Type> for ty::ProjectionTy<'tcx> {
 830     fn clean(&self, cx: &DocContext) -> Type {
 831         let trait_ = match self.trait_ref.clean(cx) {
 832             TyParamBound::TraitBound(t, _) => t.trait_,
 833             TyParamBound::RegionBound(_) => panic!("cleaning a trait got a region??"),
 834         };
 835         Type::QPath {
 836             name: self.item_name.clean(cx),
 837             self_type: box self.trait_ref.self_ty().clean(cx),
 838             trait_: box trait_
 839         }
 840     }
 841 }
 842
 843 // maybe use a Generic enum and use ~[Generic]?
 844 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
 845 pub struct Generics {
 846     pub lifetimes: Vec<Lifetime>,
 847     pub type_params: Vec<TyParam>,
 848     pub where_predicates: Vec<WherePredicate>
 849 }
 850
 851 impl Clean<Generics> for ast::Generics {
 852     fn clean(&self, cx: &DocContext) -> Generics {
 853         Generics {
 854             lifetimes: self.lifetimes.clean(cx),
 855             type_params: self.ty_params.clean(cx),
 856             where_predicates: self.where_clause.predicates.clean(cx)
 857         }
 858     }
 859 }
 860
 861 impl<'a, 'tcx> Clean<Generics> for (&'a ty::Generics<'tcx>, subst::ParamSpace) {
 862     fn clean(&self, cx: &DocContext) -> Generics {
 863         use std::collections::HashSet;
 864         use syntax::ast::TraitBoundModifier as TBM;
 865         use self::WherePredicate as WP;
 866
 867         fn has_sized_bound(bounds: &[TyParamBound], cx: &DocContext) -> bool {
 868             if let Some(tcx) = cx.tcx_opt() {
 869                 let sized_did = match tcx.lang_items.sized_trait() {
 870                     Some(did) => did,
 871                     None => return false
 872                 };
 873                 for bound in bounds.iter() {
 874                     if let TyParamBound::TraitBound(PolyTrait {
 875                         trait_: Type::ResolvedPath { did, .. }, ..
 876                     }, TBM::None) = *bound {
 877                         if did == sized_did {
 878                             return true
 879                         }
 880                     }
 881                 }
 882             }
 883             false
 884         }
 885
 886         let (gens, space) = *self;
 887         // Bounds in the type_params and lifetimes fields are repeated in the predicates
 888         // field (see rustc_typeck::collect::ty_generics), so remove them.
 889         let stripped_typarams = gens.types.get_slice(space).iter().map(|tp| {
 890             let mut stp = tp.clone();
 891             stp.bounds = ty::ParamBounds::empty();
 892             stp.clean(cx)
 893         }).collect::<Vec<_>>();
 894         let stripped_lifetimes = gens.regions.get_slice(space).iter().map(|rp| {
 895             let mut srp = rp.clone();
 896             srp.bounds = Vec::new();
 897             srp.clean(cx)
 898         }).collect::<Vec<_>>();
 899
 900         let where_predicates = gens.predicates.get_slice(space).to_vec().clean(cx);
 901         // Type parameters have a Sized bound by default unless removed with ?Sized.
 902         // Scan through the predicates and mark any type parameter with a Sized
 903         // bound, removing the bounds as we find them.
 904         let mut sized_params = HashSet::new();
 905         let mut where_predicates = where_predicates.into_iter().filter_map(|pred| {
 906             if let WP::BoundPredicate { ty: Type::Generic(ref g), ref bounds } = pred {
 907                 if has_sized_bound(&**bounds, cx) {
 908                     sized_params.insert(g.clone());
 909                     return None
 910                 }
 911             }
 912             Some(pred)
 913         }).collect::<Vec<_>>();
 914         // Finally, run through the type parameters again and insert a ?Sized unbound for
 915         // any we didn't find to be Sized.
 916         for tp in stripped_typarams.iter() {
 917             if !sized_params.contains(&tp.name) {
 918                 let mut sized_bound = ty::BuiltinBound::BoundSized.clean(cx);
 919                 if let TyParamBound::TraitBound(_, ref mut tbm) = sized_bound {
 920                     *tbm = TBM::Maybe
 921                 };
 922                 where_predicates.push(WP::BoundPredicate {
 923                     ty: Type::Generic(tp.name.clone()),
 924                     bounds: vec![sized_bound]
 925                 })
 926             }
 927         }
 928
 929         // It would be nice to collect all of the bounds on a type and recombine
 930         // them if possible, to avoid e.g. `where T: Foo, T: Bar, T: Sized, T: 'a`
 931         // and instead see `where T: Foo + Bar + Sized + 'a`
 932
 933         Generics {
 934             type_params: stripped_typarams,
 935             lifetimes: stripped_lifetimes,
 936             where_predicates: where_predicates
 937         }
 938     }
 939 }
 940
 941 #[derive(Clone, RustcEncodable, RustcDecodable)]
 942 pub struct Method {
 943     pub generics: Generics,
 944     pub self_: SelfTy,
 945     pub unsafety: ast::Unsafety,
 946     pub decl: FnDecl,
 947 }
 948
 949 impl Clean<Item> for ast::Method {
 950     fn clean(&self, cx: &DocContext) -> Item {
 951         let all_inputs = &self.pe_fn_decl().inputs;
 952         let inputs = match self.pe_explicit_self().node {
 953             ast::SelfStatic => all_inputs.as_slice(),
 954             _ => &all_inputs[1..]
 955         };
 956         let decl = FnDecl {
 957             inputs: Arguments {
 958                 values: inputs.iter().map(|x| x.clean(cx)).collect(),
 959             },
 960             output: self.pe_fn_decl().output.clean(cx),
 961             attrs: Vec::new()
 962         };
 963         Item {
 964             name: Some(self.pe_ident().clean(cx)),
 965             attrs: self.attrs.clean(cx),
 966             source: self.span.clean(cx),
 967             def_id: ast_util::local_def(self.id),
 968             visibility: self.pe_vis().clean(cx),
 969             stability: get_stability(cx, ast_util::local_def(self.id)),
 970             inner: MethodItem(Method {
 971                 generics: self.pe_generics().clean(cx),
 972                 self_: self.pe_explicit_self().node.clean(cx),
 973                 unsafety: self.pe_unsafety().clone(),
 974                 decl: decl,
 975             }),
 976         }
 977     }
 978 }
 979
 980 #[derive(Clone, RustcEncodable, RustcDecodable)]
 981 pub struct TyMethod {
 982     pub unsafety: ast::Unsafety,
 983     pub decl: FnDecl,
 984     pub generics: Generics,
 985     pub self_: SelfTy,
 986 }
 987
 988 impl Clean<Item> for ast::TypeMethod {
 989     fn clean(&self, cx: &DocContext) -> Item {
 990         let inputs = match self.explicit_self.node {
 991             ast::SelfStatic => self.decl.inputs.as_slice(),
 992             _ => &self.decl.inputs[1..]
 993         };
 994         let decl = FnDecl {
 995             inputs: Arguments {
 996                 values: inputs.iter().map(|x| x.clean(cx)).collect(),
 997             },
 998             output: self.decl.output.clean(cx),
 999             attrs: Vec::new()
1000         };
1001         Item {
1002             name: Some(self.ident.clean(cx)),
1003             attrs: self.attrs.clean(cx),
1004             source: self.span.clean(cx),
1005             def_id: ast_util::local_def(self.id),
1006             visibility: None,
1007             stability: get_stability(cx, ast_util::local_def(self.id)),
1008             inner: TyMethodItem(TyMethod {
1009                 unsafety: self.unsafety.clone(),
1010                 decl: decl,
1011                 self_: self.explicit_self.node.clean(cx),
1012                 generics: self.generics.clean(cx),
1013             }),
1014         }
1015     }
1016 }
1017
1018 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq)]
1019 pub enum SelfTy {
1020     SelfStatic,
1021     SelfValue,
1022     SelfBorrowed(Option<Lifetime>, Mutability),
1023     SelfExplicit(Type),
1024 }
1025
1026 impl Clean<SelfTy> for ast::ExplicitSelf_ {
1027     fn clean(&self, cx: &DocContext) -> SelfTy {
1028         match *self {
1029             ast::SelfStatic => SelfStatic,
1030             ast::SelfValue(_) => SelfValue,
1031             ast::SelfRegion(ref lt, ref mt, _) => {
1032                 SelfBorrowed(lt.clean(cx), mt.clean(cx))
1033             }
1034             ast::SelfExplicit(ref typ, _) => SelfExplicit(typ.clean(cx)),
1035         }
1036     }
1037 }
1038
1039 #[derive(Clone, RustcEncodable, RustcDecodable)]
1040 pub struct Function {
1041     pub decl: FnDecl,
1042     pub generics: Generics,
1043     pub unsafety: ast::Unsafety,
1044 }
1045
1046 impl Clean<Item> for doctree::Function {
1047     fn clean(&self, cx: &DocContext) -> Item {
1048         Item {
1049             name: Some(self.name.clean(cx)),
1050             attrs: self.attrs.clean(cx),
1051             source: self.whence.clean(cx),
1052             visibility: self.vis.clean(cx),
1053             stability: self.stab.clean(cx),
1054             def_id: ast_util::local_def(self.id),
1055             inner: FunctionItem(Function {
1056                 decl: self.decl.clean(cx),
1057                 generics: self.generics.clean(cx),
1058                 unsafety: self.unsafety,
1059             }),
1060         }
1061     }
1062 }
1063
1064 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
1065 pub struct FnDecl {
1066     pub inputs: Arguments,
1067     pub output: FunctionRetTy,
1068     pub attrs: Vec<Attribute>,
1069 }
1070
1071 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
1072 pub struct Arguments {
1073     pub values: Vec<Argument>,
1074 }
1075
1076 impl Clean<FnDecl> for ast::FnDecl {
1077     fn clean(&self, cx: &DocContext) -> FnDecl {
1078         FnDecl {
1079             inputs: Arguments {
1080                 values: self.inputs.clean(cx),
1081             },
1082             output: self.output.clean(cx),
1083             attrs: Vec::new()
1084         }
1085     }
1086 }
1087
1088 impl<'tcx> Clean<Type> for ty::FnOutput<'tcx> {
1089     fn clean(&self, cx: &DocContext) -> Type {
1090         match *self {
1091             ty::FnConverging(ty) => ty.clean(cx),
1092             ty::FnDiverging => Bottom
1093         }
1094     }
1095 }
1096
1097 impl<'a, 'tcx> Clean<FnDecl> for (ast::DefId, &'a ty::PolyFnSig<'tcx>) {
1098     fn clean(&self, cx: &DocContext) -> FnDecl {
1099         let (did, sig) = *self;
1100         let mut names = if did.node != 0 {
1101             csearch::get_method_arg_names(&cx.tcx().sess.cstore, did).into_iter()
1102         } else {
1103             Vec::new().into_iter()
1104         }.peekable();
1105         if names.peek().map(|s| s.as_slice()) == Some("self") {
1106             let _ = names.next();
1107         }
1108         FnDecl {
1109             output: Return(sig.0.output.clean(cx)),
1110             attrs: Vec::new(),
1111             inputs: Arguments {
1112                 values: sig.0.inputs.iter().map(|t| {
1113                     Argument {
1114                         type_: t.clean(cx),
1115                         id: 0,
1116                         name: names.next().unwrap_or("".to_string()),
1117                     }
1118                 }).collect(),
1119             },
1120         }
1121     }
1122 }
1123
1124 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
1125 pub struct Argument {
1126     pub type_: Type,
1127     pub name: String,
1128     pub id: ast::NodeId,
1129 }
1130
1131 impl Clean<Argument> for ast::Arg {
1132     fn clean(&self, cx: &DocContext) -> Argument {
1133         Argument {
1134             name: name_from_pat(&*self.pat),
1135             type_: (self.ty.clean(cx)),
1136             id: self.id
1137         }
1138     }
1139 }
1140
1141 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
1142 pub enum FunctionRetTy {
1143     Return(Type),
1144     DefaultReturn,
1145     NoReturn
1146 }
1147
1148 impl Clean<FunctionRetTy> for ast::FunctionRetTy {
1149     fn clean(&self, cx: &DocContext) -> FunctionRetTy {
1150         match *self {
1151             ast::Return(ref typ) => Return(typ.clean(cx)),
1152             ast::DefaultReturn(..) => DefaultReturn,
1153             ast::NoReturn(..) => NoReturn
1154         }
1155     }
1156 }
1157
1158 #[derive(Clone, RustcEncodable, RustcDecodable)]
1159 pub struct Trait {
1160     pub unsafety: ast::Unsafety,
1161     pub items: Vec<TraitMethod>,
1162     pub generics: Generics,
1163     pub bounds: Vec<TyParamBound>,
1164 }
1165
1166 impl Clean<Item> for doctree::Trait {
1167     fn clean(&self, cx: &DocContext) -> Item {
1168         Item {
1169             name: Some(self.name.clean(cx)),
1170             attrs: self.attrs.clean(cx),
1171             source: self.whence.clean(cx),
1172             def_id: ast_util::local_def(self.id),
1173             visibility: self.vis.clean(cx),
1174             stability: self.stab.clean(cx),
1175             inner: TraitItem(Trait {
1176                 unsafety: self.unsafety,
1177                 items: self.items.clean(cx),
1178                 generics: self.generics.clean(cx),
1179                 bounds: self.bounds.clean(cx),
1180             }),
1181         }
1182     }
1183 }
1184
1185 impl Clean<Type> for ast::TraitRef {
1186     fn clean(&self, cx: &DocContext) -> Type {
1187         resolve_type(cx, self.path.clean(cx), self.ref_id)
1188     }
1189 }
1190
1191 impl Clean<PolyTrait> for ast::PolyTraitRef {
1192     fn clean(&self, cx: &DocContext) -> PolyTrait {
1193         PolyTrait {
1194             trait_: self.trait_ref.clean(cx),
1195             lifetimes: self.bound_lifetimes.clean(cx)
1196         }
1197     }
1198 }
1199
1200 /// An item belonging to a trait, whether a method or associated. Could be named
1201 /// TraitItem except that's already taken by an exported enum variant.
1202 #[derive(Clone, RustcEncodable, RustcDecodable)]
1203 pub enum TraitMethod {
1204     RequiredMethod(Item),
1205     ProvidedMethod(Item),
1206     TypeTraitItem(Item),
1207 }
1208
1209 impl TraitMethod {
1210     pub fn is_req(&self) -> bool {
1211         match self {
1212             &RequiredMethod(..) => true,
1213             _ => false,
1214         }
1215     }
1216     pub fn is_def(&self) -> bool {
1217         match self {
1218             &ProvidedMethod(..) => true,
1219             _ => false,
1220         }
1221     }
1222     pub fn is_type(&self) -> bool {
1223         match self {
1224             &TypeTraitItem(..) => true,
1225             _ => false,
1226         }
1227     }
1228     pub fn item<'a>(&'a self) -> &'a Item {
1229         match *self {
1230             RequiredMethod(ref item) => item,
1231             ProvidedMethod(ref item) => item,
1232             TypeTraitItem(ref item) => item,
1233         }
1234     }
1235 }
1236
1237 impl Clean<TraitMethod> for ast::TraitItem {
1238     fn clean(&self, cx: &DocContext) -> TraitMethod {
1239         match self {
1240             &ast::RequiredMethod(ref t) => RequiredMethod(t.clean(cx)),
1241             &ast::ProvidedMethod(ref t) => ProvidedMethod(t.clean(cx)),
1242             &ast::TypeTraitItem(ref t) => TypeTraitItem(t.clean(cx)),
1243         }
1244     }
1245 }
1246
1247 #[derive(Clone, RustcEncodable, RustcDecodable)]
1248 pub enum ImplMethod {
1249     MethodImplItem(Item),
1250     TypeImplItem(Item),
1251 }
1252
1253 impl Clean<ImplMethod> for ast::ImplItem {
1254     fn clean(&self, cx: &DocContext) -> ImplMethod {
1255         match self {
1256             &ast::MethodImplItem(ref t) => MethodImplItem(t.clean(cx)),
1257             &ast::TypeImplItem(ref t) => TypeImplItem(t.clean(cx)),
1258         }
1259     }
1260 }
1261
1262 impl<'tcx> Clean<Item> for ty::Method<'tcx> {
1263     fn clean(&self, cx: &DocContext) -> Item {
1264         let (self_, sig) = match self.explicit_self {
1265             ty::StaticExplicitSelfCategory => (ast::SelfStatic.clean(cx),
1266                                                self.fty.sig.clone()),
1267             s => {
1268                 let sig = ty::Binder(ty::FnSig {
1269                     inputs: self.fty.sig.0.inputs[1..].to_vec(),
1270                     ..self.fty.sig.0.clone()
1271                 });
1272                 let s = match s {
1273                     ty::ByValueExplicitSelfCategory => SelfValue,
1274                     ty::ByReferenceExplicitSelfCategory(..) => {
1275                         match self.fty.sig.0.inputs[0].sty {
1276                             ty::ty_rptr(r, mt) => {
1277                                 SelfBorrowed(r.clean(cx), mt.mutbl.clean(cx))
1278                             }
1279                             _ => unreachable!(),
1280                         }
1281                     }
1282                     ty::ByBoxExplicitSelfCategory => {
1283                         SelfExplicit(self.fty.sig.0.inputs[0].clean(cx))
1284                     }
1285                     ty::StaticExplicitSelfCategory => unreachable!(),
1286                 };
1287                 (s, sig)
1288             }
1289         };
1290
1291         Item {
1292             name: Some(self.name.clean(cx)),
1293             visibility: Some(ast::Inherited),
1294             stability: get_stability(cx, self.def_id),
1295             def_id: self.def_id,
1296             attrs: inline::load_attrs(cx, cx.tcx(), self.def_id),
1297             source: Span::empty(),
1298             inner: TyMethodItem(TyMethod {
1299                 unsafety: self.fty.unsafety,
1300                 generics: (&self.generics, subst::FnSpace).clean(cx),
1301                 self_: self_,
1302                 decl: (self.def_id, &sig).clean(cx),
1303             })
1304         }
1305     }
1306 }
1307
1308 impl<'tcx> Clean<Item> for ty::ImplOrTraitItem<'tcx> {
1309     fn clean(&self, cx: &DocContext) -> Item {
1310         match *self {
1311             ty::MethodTraitItem(ref mti) => mti.clean(cx),
1312             ty::TypeTraitItem(ref tti) => tti.clean(cx),
1313         }
1314     }
1315 }
1316
1317 /// A trait reference, which may have higher ranked lifetimes.
1318 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
1319 pub struct PolyTrait {
1320     pub trait_: Type,
1321     pub lifetimes: Vec<Lifetime>
1322 }
1323
1324 /// A representation of a Type suitable for hyperlinking purposes. Ideally one can get the original
1325 /// type out of the AST/ty::ctxt given one of these, if more information is needed. Most importantly
1326 /// it does not preserve mutability or boxes.
1327 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
1328 pub enum Type {
1329     /// structs/enums/traits (anything that'd be an ast::TyPath)
1330     ResolvedPath {
1331         path: Path,
1332         typarams: Option<Vec<TyParamBound>>,
1333         did: ast::DefId,
1334     },
1335     // I have no idea how to usefully use this.
1336     TyParamBinder(ast::NodeId),
1337     /// For parameterized types, so the consumer of the JSON don't go
1338     /// looking for types which don't exist anywhere.
1339     Generic(String),
1340     /// Primitives are just the fixed-size numeric types (plus int/uint/float), and char.
1341     Primitive(PrimitiveType),
1342     /// extern "ABI" fn
1343     BareFunction(Box<BareFunctionDecl>),
1344     Tuple(Vec<Type>),
1345     Vector(Box<Type>),
1346     FixedVector(Box<Type>, String),
1347     /// aka TyBot
1348     Bottom,
1349     Unique(Box<Type>),
1350     RawPointer(Mutability, Box<Type>),
1351     BorrowedRef {
1352         lifetime: Option<Lifetime>,
1353         mutability: Mutability,
1354         type_: Box<Type>,
1355     },
1356
1357     // <Type as Trait>::Name
1358     QPath {
1359         name: String,
1360         self_type: Box<Type>,
1361         trait_: Box<Type>
1362     },
1363
1364     // _
1365     Infer,
1366
1367     // for<'a> Foo(&'a)
1368     PolyTraitRef(Vec<TyParamBound>),
1369 }
1370
1371 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Copy, Show)]
1372 pub enum PrimitiveType {
1373     Isize, I8, I16, I32, I64,
1374     Usize, U8, U16, U32, U64,
1375     F32, F64,
1376     Char,
1377     Bool,
1378     Str,
1379     Slice,
1380     PrimitiveTuple,
1381 }
1382
1383 #[derive(Clone, RustcEncodable, RustcDecodable, Copy)]
1384 pub enum TypeKind {
1385     TypeEnum,
1386     TypeFunction,
1387     TypeModule,
1388     TypeConst,
1389     TypeStatic,
1390     TypeStruct,
1391     TypeTrait,
1392     TypeVariant,
1393     TypeTypedef,
1394 }
1395
1396 impl PrimitiveType {
1397     fn from_str(s: &str) -> Option<PrimitiveType> {
1398         match s.as_slice() {
1399             "isize" | "int" => Some(Isize),
1400             "i8" => Some(I8),
1401             "i16" => Some(I16),
1402             "i32" => Some(I32),
1403             "i64" => Some(I64),
1404             "usize" | "uint" => Some(Usize),
1405             "u8" => Some(U8),
1406             "u16" => Some(U16),
1407             "u32" => Some(U32),
1408             "u64" => Some(U64),
1409             "bool" => Some(Bool),
1410             "char" => Some(Char),
1411             "str" => Some(Str),
1412             "f32" => Some(F32),
1413             "f64" => Some(F64),
1414             "slice" => Some(Slice),
1415             "tuple" => Some(PrimitiveTuple),
1416             _ => None,
1417         }
1418     }
1419
1420     fn find(attrs: &[Attribute]) -> Option<PrimitiveType> {
1421         for attr in attrs.iter() {
1422             let list = match *attr {
1423                 List(ref k, ref l) if *k == "doc" => l,
1424                 _ => continue,
1425             };
1426             for sub_attr in list.iter() {
1427                 let value = match *sub_attr {
1428                     NameValue(ref k, ref v)
1429                         if *k == "primitive" => v.as_slice(),
1430                     _ => continue,
1431                 };
1432                 match PrimitiveType::from_str(value) {
1433                     Some(p) => return Some(p),
1434                     None => {}
1435                 }
1436             }
1437         }
1438         return None
1439     }
1440
1441     pub fn to_string(&self) -> &'static str {
1442         match *self {
1443             Isize => "isize",
1444             I8 => "i8",
1445             I16 => "i16",
1446             I32 => "i32",
1447             I64 => "i64",
1448             Usize => "usize",
1449             U8 => "u8",
1450             U16 => "u16",
1451             U32 => "u32",
1452             U64 => "u64",
1453             F32 => "f32",
1454             F64 => "f64",
1455             Str => "str",
1456             Bool => "bool",
1457             Char => "char",
1458             Slice => "slice",
1459             PrimitiveTuple => "tuple",
1460         }
1461     }
1462
1463     pub fn to_url_str(&self) -> &'static str {
1464         self.to_string()
1465     }
1466
1467     /// Creates a rustdoc-specific node id for primitive types.
1468     ///
1469     /// These node ids are generally never used by the AST itself.
1470     pub fn to_node_id(&self) -> ast::NodeId {
1471         u32::MAX - 1 - (*self as u32)
1472     }
1473 }
1474
1475 impl Clean<Type> for ast::Ty {
1476     fn clean(&self, cx: &DocContext) -> Type {
1477         use syntax::ast::*;
1478         match self.node {
1479             TyPtr(ref m) => RawPointer(m.mutbl.clean(cx), box m.ty.clean(cx)),
1480             TyRptr(ref l, ref m) =>
1481                 BorrowedRef {lifetime: l.clean(cx), mutability: m.mutbl.clean(cx),
1482                              type_: box m.ty.clean(cx)},
1483             TyVec(ref ty) => Vector(box ty.clean(cx)),
1484             TyFixedLengthVec(ref ty, ref e) => FixedVector(box ty.clean(cx),
1485                                                            e.span.to_src(cx)),
1486             TyTup(ref tys) => Tuple(tys.clean(cx)),
1487             TyPath(ref p, id) => {
1488                 resolve_type(cx, p.clean(cx), id)
1489             }
1490             TyObjectSum(ref lhs, ref bounds) => {
1491                 let lhs_ty = lhs.clean(cx);
1492                 match lhs_ty {
1493                     ResolvedPath { path, typarams: None, did } => {
1494                         ResolvedPath { path: path, typarams: Some(bounds.clean(cx)), did: did}
1495                     }
1496                     _ => {
1497                         lhs_ty // shouldn't happen
1498                     }
1499                 }
1500             }
1501             TyBareFn(ref barefn) => BareFunction(box barefn.clean(cx)),
1502             TyParen(ref ty) => ty.clean(cx),
1503             TyQPath(ref qp) => qp.clean(cx),
1504             TyPolyTraitRef(ref bounds) => {
1505                 PolyTraitRef(bounds.clean(cx))
1506             },
1507             TyInfer(..) => {
1508                 Infer
1509             },
1510             TyTypeof(..) => {
1511                 panic!("Unimplemented type {:?}", self.node)
1512             },
1513         }
1514     }
1515 }
1516
1517 impl<'tcx> Clean<Type> for ty::Ty<'tcx> {
1518     fn clean(&self, cx: &DocContext) -> Type {
1519         match self.sty {
1520             ty::ty_bool => Primitive(Bool),
1521             ty::ty_char => Primitive(Char),
1522             ty::ty_int(ast::TyIs(_)) => Primitive(Isize),
1523             ty::ty_int(ast::TyI8) => Primitive(I8),
1524             ty::ty_int(ast::TyI16) => Primitive(I16),
1525             ty::ty_int(ast::TyI32) => Primitive(I32),
1526             ty::ty_int(ast::TyI64) => Primitive(I64),
1527             ty::ty_uint(ast::TyUs(_)) => Primitive(Usize),
1528             ty::ty_uint(ast::TyU8) => Primitive(U8),
1529             ty::ty_uint(ast::TyU16) => Primitive(U16),
1530             ty::ty_uint(ast::TyU32) => Primitive(U32),
1531             ty::ty_uint(ast::TyU64) => Primitive(U64),
1532             ty::ty_float(ast::TyF32) => Primitive(F32),
1533             ty::ty_float(ast::TyF64) => Primitive(F64),
1534             ty::ty_str => Primitive(Str),
1535             ty::ty_uniq(t) => {
1536                 let box_did = cx.tcx_opt().and_then(|tcx| {
1537                     tcx.lang_items.owned_box()
1538                 });
1539                 lang_struct(cx, box_did, t, "Box", Unique)
1540             }
1541             ty::ty_vec(ty, None) => Vector(box ty.clean(cx)),
1542             ty::ty_vec(ty, Some(i)) => FixedVector(box ty.clean(cx),
1543                                                    format!("{}", i)),
1544             ty::ty_ptr(mt) => RawPointer(mt.mutbl.clean(cx), box mt.ty.clean(cx)),
1545             ty::ty_rptr(r, mt) => BorrowedRef {
1546                 lifetime: r.clean(cx),
1547                 mutability: mt.mutbl.clean(cx),
1548                 type_: box mt.ty.clean(cx),
1549             },
1550             ty::ty_bare_fn(_, ref fty) => BareFunction(box BareFunctionDecl {
1551                 unsafety: fty.unsafety,
1552                 generics: Generics {
1553                     lifetimes: Vec::new(),
1554                     type_params: Vec::new(),
1555                     where_predicates: Vec::new()
1556                 },
1557                 decl: (ast_util::local_def(0), &fty.sig).clean(cx),
1558                 abi: fty.abi.to_string(),
1559             }),
1560             ty::ty_struct(did, substs) |
1561             ty::ty_enum(did, substs) => {
1562                 let fqn = csearch::get_item_path(cx.tcx(), did);
1563                 let fqn: Vec<_> = fqn.into_iter().map(|i| i.to_string()).collect();
1564                 let kind = match self.sty {
1565                     ty::ty_struct(..) => TypeStruct,
1566                     _ => TypeEnum,
1567                 };
1568                 let path = external_path(cx, fqn.last().unwrap().to_string().as_slice(),
1569                                          None, vec![], substs);
1570                 cx.external_paths.borrow_mut().as_mut().unwrap().insert(did, (fqn, kind));
1571                 ResolvedPath {
1572                     path: path,
1573                     typarams: None,
1574                     did: did,
1575                 }
1576             }
1577             ty::ty_trait(box ty::TyTrait { ref principal, ref bounds }) => {
1578                 let did = principal.def_id();
1579                 let fqn = csearch::get_item_path(cx.tcx(), did);
1580                 let fqn: Vec<_> = fqn.into_iter().map(|i| i.to_string()).collect();
1581                 let (typarams, bindings) = bounds.clean(cx);
1582                 let path = external_path(cx, fqn.last().unwrap().to_string().as_slice(),
1583                                          Some(did), bindings, principal.substs());
1584                 cx.external_paths.borrow_mut().as_mut().unwrap().insert(did, (fqn, TypeTrait));
1585                 ResolvedPath {
1586                     path: path,
1587                     typarams: Some(typarams),
1588                     did: did,
1589                 }
1590             }
1591             ty::ty_tup(ref t) => Tuple(t.clean(cx)),
1592
1593             ty::ty_projection(ref data) => {
1594                 let trait_ref = match data.trait_ref.clean(cx) {
1595                     TyParamBound::TraitBound(t, _) => t.trait_,
1596                     TyParamBound::RegionBound(_) => panic!("cleaning a trait got a region??"),
1597                 };
1598                 Type::QPath {
1599                     name: data.item_name.clean(cx),
1600                     self_type: box data.trait_ref.self_ty().clean(cx),
1601                     trait_: box trait_ref,
1602                 }
1603             }
1604
1605             ty::ty_param(ref p) => Generic(token::get_name(p.name).to_string()),
1606
1607             ty::ty_unboxed_closure(..) => Tuple(vec![]), // FIXME(pcwalton)
1608
1609             ty::ty_infer(..) => panic!("ty_infer"),
1610             ty::ty_open(..) => panic!("ty_open"),
1611             ty::ty_err => panic!("ty_err"),
1612         }
1613     }
1614 }
1615
1616 impl Clean<Type> for ast::QPath {
1617     fn clean(&self, cx: &DocContext) -> Type {
1618         Type::QPath {
1619             name: self.item_path.identifier.clean(cx),
1620             self_type: box self.self_type.clean(cx),
1621             trait_: box self.trait_ref.clean(cx)
1622         }
1623     }
1624 }
1625
1626 #[derive(Clone, RustcEncodable, RustcDecodable)]
1627 pub enum StructField {
1628     HiddenStructField, // inserted later by strip passes
1629     TypedStructField(Type),
1630 }
1631
1632 impl Clean<Item> for ast::StructField {
1633     fn clean(&self, cx: &DocContext) -> Item {
1634         let (name, vis) = match self.node.kind {
1635             ast::NamedField(id, vis) => (Some(id), vis),
1636             ast::UnnamedField(vis) => (None, vis)
1637         };
1638         Item {
1639             name: name.clean(cx),
1640             attrs: self.node.attrs.clean(cx),
1641             source: self.span.clean(cx),
1642             visibility: Some(vis),
1643             stability: get_stability(cx, ast_util::local_def(self.node.id)),
1644             def_id: ast_util::local_def(self.node.id),
1645             inner: StructFieldItem(TypedStructField(self.node.ty.clean(cx))),
1646         }
1647     }
1648 }
1649
1650 impl Clean<Item> for ty::field_ty {
1651     fn clean(&self, cx: &DocContext) -> Item {
1652         use syntax::parse::token::special_idents::unnamed_field;
1653         use rustc::metadata::csearch;
1654
1655         let attr_map = csearch::get_struct_field_attrs(&cx.tcx().sess.cstore, self.id);
1656
1657         let (name, attrs) = if self.name == unnamed_field.name {
1658             (None, None)
1659         } else {
1660             (Some(self.name), Some(attr_map.get(&self.id.node).unwrap()))
1661         };
1662
1663         let ty = ty::lookup_item_type(cx.tcx(), self.id);
1664
1665         Item {
1666             name: name.clean(cx),
1667             attrs: attrs.unwrap_or(&Vec::new()).clean(cx),
1668             source: Span::empty(),
1669             visibility: Some(self.vis),
1670             stability: get_stability(cx, self.id),
1671             def_id: self.id,
1672             inner: StructFieldItem(TypedStructField(ty.ty.clean(cx))),
1673         }
1674     }
1675 }
1676
1677 pub type Visibility = ast::Visibility;
1678
1679 impl Clean<Option<Visibility>> for ast::Visibility {
1680     fn clean(&self, _: &DocContext) -> Option<Visibility> {
1681         Some(*self)
1682     }
1683 }
1684
1685 #[derive(Clone, RustcEncodable, RustcDecodable)]
1686 pub struct Struct {
1687     pub struct_type: doctree::StructType,
1688     pub generics: Generics,
1689     pub fields: Vec<Item>,
1690     pub fields_stripped: bool,
1691 }
1692
1693 impl Clean<Item> for doctree::Struct {
1694     fn clean(&self, cx: &DocContext) -> Item {
1695         Item {
1696             name: Some(self.name.clean(cx)),
1697             attrs: self.attrs.clean(cx),
1698             source: self.whence.clean(cx),
1699             def_id: ast_util::local_def(self.id),
1700             visibility: self.vis.clean(cx),
1701             stability: self.stab.clean(cx),
1702             inner: StructItem(Struct {
1703                 struct_type: self.struct_type,
1704                 generics: self.generics.clean(cx),
1705                 fields: self.fields.clean(cx),
1706                 fields_stripped: false,
1707             }),
1708         }
1709     }
1710 }
1711
1712 /// This is a more limited form of the standard Struct, different in that
1713 /// it lacks the things most items have (name, id, parameterization). Found
1714 /// only as a variant in an enum.
1715 #[derive(Clone, RustcEncodable, RustcDecodable)]
1716 pub struct VariantStruct {
1717     pub struct_type: doctree::StructType,
1718     pub fields: Vec<Item>,
1719     pub fields_stripped: bool,
1720 }
1721
1722 impl Clean<VariantStruct> for syntax::ast::StructDef {
1723     fn clean(&self, cx: &DocContext) -> VariantStruct {
1724         VariantStruct {
1725             struct_type: doctree::struct_type_from_def(self),
1726             fields: self.fields.clean(cx),
1727             fields_stripped: false,
1728         }
1729     }
1730 }
1731
1732 #[derive(Clone, RustcEncodable, RustcDecodable)]
1733 pub struct Enum {
1734     pub variants: Vec<Item>,
1735     pub generics: Generics,
1736     pub variants_stripped: bool,
1737 }
1738
1739 impl Clean<Item> for doctree::Enum {
1740     fn clean(&self, cx: &DocContext) -> Item {
1741         Item {
1742             name: Some(self.name.clean(cx)),
1743             attrs: self.attrs.clean(cx),
1744             source: self.whence.clean(cx),
1745             def_id: ast_util::local_def(self.id),
1746             visibility: self.vis.clean(cx),
1747             stability: self.stab.clean(cx),
1748             inner: EnumItem(Enum {
1749                 variants: self.variants.clean(cx),
1750                 generics: self.generics.clean(cx),
1751                 variants_stripped: false,
1752             }),
1753         }
1754     }
1755 }
1756
1757 #[derive(Clone, RustcEncodable, RustcDecodable)]
1758 pub struct Variant {
1759     pub kind: VariantKind,
1760 }
1761
1762 impl Clean<Item> for doctree::Variant {
1763     fn clean(&self, cx: &DocContext) -> Item {
1764         Item {
1765             name: Some(self.name.clean(cx)),
1766             attrs: self.attrs.clean(cx),
1767             source: self.whence.clean(cx),
1768             visibility: self.vis.clean(cx),
1769             stability: self.stab.clean(cx),
1770             def_id: ast_util::local_def(self.id),
1771             inner: VariantItem(Variant {
1772                 kind: self.kind.clean(cx),
1773             }),
1774         }
1775     }
1776 }
1777
1778 impl<'tcx> Clean<Item> for ty::VariantInfo<'tcx> {
1779     fn clean(&self, cx: &DocContext) -> Item {
1780         // use syntax::parse::token::special_idents::unnamed_field;
1781         let kind = match self.arg_names.as_ref().map(|s| s.as_slice()) {
1782             None | Some([]) if self.args.len() == 0 => CLikeVariant,
1783             None | Some([]) => {
1784                 TupleVariant(self.args.clean(cx))
1785             }
1786             Some(s) => {
1787                 StructVariant(VariantStruct {
1788                     struct_type: doctree::Plain,
1789                     fields_stripped: false,
1790                     fields: s.iter().zip(self.args.iter()).map(|(name, ty)| {
1791                         Item {
1792                             source: Span::empty(),
1793                             name: Some(name.clean(cx)),
1794                             attrs: Vec::new(),
1795                             visibility: Some(ast::Public),
1796                             // FIXME: this is not accurate, we need an id for
1797                             //        the specific field but we're using the id
1798                             //        for the whole variant. Thus we read the
1799                             //        stability from the whole variant as well.
1800                             //        Struct variants are experimental and need
1801                             //        more infrastructure work before we can get
1802                             //        at the needed information here.
1803                             def_id: self.id,
1804                             stability: get_stability(cx, self.id),
1805                             inner: StructFieldItem(
1806                                 TypedStructField(ty.clean(cx))
1807                             )
1808                         }
1809                     }).collect()
1810                 })
1811             }
1812         };
1813         Item {
1814             name: Some(self.name.clean(cx)),
1815             attrs: inline::load_attrs(cx, cx.tcx(), self.id),
1816             source: Span::empty(),
1817             visibility: Some(ast::Public),
1818             def_id: self.id,
1819             inner: VariantItem(Variant { kind: kind }),
1820             stability: get_stability(cx, self.id),
1821         }
1822     }
1823 }
1824
1825 #[derive(Clone, RustcEncodable, RustcDecodable)]
1826 pub enum VariantKind {
1827     CLikeVariant,
1828     TupleVariant(Vec<Type>),
1829     StructVariant(VariantStruct),
1830 }
1831
1832 impl Clean<VariantKind> for ast::VariantKind {
1833     fn clean(&self, cx: &DocContext) -> VariantKind {
1834         match self {
1835             &ast::TupleVariantKind(ref args) => {
1836                 if args.len() == 0 {
1837                     CLikeVariant
1838                 } else {
1839                     TupleVariant(args.iter().map(|x| x.ty.clean(cx)).collect())
1840                 }
1841             },
1842             &ast::StructVariantKind(ref sd) => StructVariant(sd.clean(cx)),
1843         }
1844     }
1845 }
1846
1847 #[derive(Clone, RustcEncodable, RustcDecodable, Show)]
1848 pub struct Span {
1849     pub filename: String,
1850     pub loline: uint,
1851     pub locol: uint,
1852     pub hiline: uint,
1853     pub hicol: uint,
1854 }
1855
1856 impl Span {
1857     fn empty() -> Span {
1858         Span {
1859             filename: "".to_string(),
1860             loline: 0, locol: 0,
1861             hiline: 0, hicol: 0,
1862         }
1863     }
1864 }
1865
1866 impl Clean<Span> for syntax::codemap::Span {
1867     fn clean(&self, cx: &DocContext) -> Span {
1868         let cm = cx.sess().codemap();
1869         let filename = cm.span_to_filename(*self);
1870         let lo = cm.lookup_char_pos(self.lo);
1871         let hi = cm.lookup_char_pos(self.hi);
1872         Span {
1873             filename: filename.to_string(),
1874             loline: lo.line,
1875             locol: lo.col.to_uint(),
1876             hiline: hi.line,
1877             hicol: hi.col.to_uint(),
1878         }
1879     }
1880 }
1881
1882 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
1883 pub struct Path {
1884     pub global: bool,
1885     pub segments: Vec<PathSegment>,
1886 }
1887
1888 impl Clean<Path> for ast::Path {
1889     fn clean(&self, cx: &DocContext) -> Path {
1890         Path {
1891             global: self.global,
1892             segments: self.segments.clean(cx),
1893         }
1894     }
1895 }
1896
1897 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
1898 pub enum PathParameters {
1899     AngleBracketed {
1900         lifetimes: Vec<Lifetime>,
1901         types: Vec<Type>,
1902         bindings: Vec<TypeBinding>
1903     },
1904     Parenthesized {
1905         inputs: Vec<Type>,
1906         output: Option<Type>
1907     }
1908 }
1909
1910 impl Clean<PathParameters> for ast::PathParameters {
1911     fn clean(&self, cx: &DocContext) -> PathParameters {
1912         match *self {
1913             ast::AngleBracketedParameters(ref data) => {
1914                 PathParameters::AngleBracketed {
1915                     lifetimes: data.lifetimes.clean(cx),
1916                     types: data.types.clean(cx),
1917                     bindings: data.bindings.clean(cx)
1918                 }
1919             }
1920
1921             ast::ParenthesizedParameters(ref data) => {
1922                 PathParameters::Parenthesized {
1923                     inputs: data.inputs.clean(cx),
1924                     output: data.output.clean(cx)
1925                 }
1926             }
1927         }
1928     }
1929 }
1930
1931 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
1932 pub struct PathSegment {
1933     pub name: String,
1934     pub params: PathParameters
1935 }
1936
1937 impl Clean<PathSegment> for ast::PathSegment {
1938     fn clean(&self, cx: &DocContext) -> PathSegment {
1939         PathSegment {
1940             name: self.identifier.clean(cx),
1941             params: self.parameters.clean(cx)
1942         }
1943     }
1944 }
1945
1946 fn path_to_string(p: &ast::Path) -> String {
1947     let mut s = String::new();
1948     let mut first = true;
1949     for i in p.segments.iter().map(|x| token::get_ident(x.identifier)) {
1950         if !first || p.global {
1951             s.push_str("::");
1952         } else {
1953             first = false;
1954         }
1955         s.push_str(i.get());
1956     }
1957     s
1958 }
1959
1960 impl Clean<String> for ast::Ident {
1961     fn clean(&self, _: &DocContext) -> String {
1962         token::get_ident(*self).get().to_string()
1963     }
1964 }
1965
1966 impl Clean<String> for ast::Name {
1967     fn clean(&self, _: &DocContext) -> String {
1968         token::get_name(*self).get().to_string()
1969     }
1970 }
1971
1972 #[derive(Clone, RustcEncodable, RustcDecodable)]
1973 pub struct Typedef {
1974     pub type_: Type,
1975     pub generics: Generics,
1976 }
1977
1978 impl Clean<Item> for doctree::Typedef {
1979     fn clean(&self, cx: &DocContext) -> Item {
1980         Item {
1981             name: Some(self.name.clean(cx)),
1982             attrs: self.attrs.clean(cx),
1983             source: self.whence.clean(cx),
1984             def_id: ast_util::local_def(self.id.clone()),
1985             visibility: self.vis.clean(cx),
1986             stability: self.stab.clean(cx),
1987             inner: TypedefItem(Typedef {
1988                 type_: self.ty.clean(cx),
1989                 generics: self.gen.clean(cx),
1990             }),
1991         }
1992     }
1993 }
1994
1995 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Show)]
1996 pub struct BareFunctionDecl {
1997     pub unsafety: ast::Unsafety,
1998     pub generics: Generics,
1999     pub decl: FnDecl,
2000     pub abi: String,
2001 }
2002
2003 impl Clean<BareFunctionDecl> for ast::BareFnTy {
2004     fn clean(&self, cx: &DocContext) -> BareFunctionDecl {
2005         BareFunctionDecl {
2006             unsafety: self.unsafety,
2007             generics: Generics {
2008                 lifetimes: self.lifetimes.clean(cx),
2009                 type_params: Vec::new(),
2010                 where_predicates: Vec::new()
2011             },
2012             decl: self.decl.clean(cx),
2013             abi: self.abi.to_string(),
2014         }
2015     }
2016 }
2017
2018 #[derive(Clone, RustcEncodable, RustcDecodable, Show)]
2019 pub struct Static {
2020     pub type_: Type,
2021     pub mutability: Mutability,
2022     /// It's useful to have the value of a static documented, but I have no
2023     /// desire to represent expressions (that'd basically be all of the AST,
2024     /// which is huge!). So, have a string.
2025     pub expr: String,
2026 }
2027
2028 impl Clean<Item> for doctree::Static {
2029     fn clean(&self, cx: &DocContext) -> Item {
2030         debug!("cleaning static {}: {:?}", self.name.clean(cx), self);
2031         Item {
2032             name: Some(self.name.clean(cx)),
2033             attrs: self.attrs.clean(cx),
2034             source: self.whence.clean(cx),
2035             def_id: ast_util::local_def(self.id),
2036             visibility: self.vis.clean(cx),
2037             stability: self.stab.clean(cx),
2038             inner: StaticItem(Static {
2039                 type_: self.type_.clean(cx),
2040                 mutability: self.mutability.clean(cx),
2041                 expr: self.expr.span.to_src(cx),
2042             }),
2043         }
2044     }
2045 }
2046
2047 #[derive(Clone, RustcEncodable, RustcDecodable, Show)]
2048 pub struct Constant {
2049     pub type_: Type,
2050     pub expr: String,
2051 }
2052
2053 impl Clean<Item> for doctree::Constant {
2054     fn clean(&self, cx: &DocContext) -> Item {
2055         Item {
2056             name: Some(self.name.clean(cx)),
2057             attrs: self.attrs.clean(cx),
2058             source: self.whence.clean(cx),
2059             def_id: ast_util::local_def(self.id),
2060             visibility: self.vis.clean(cx),
2061             stability: self.stab.clean(cx),
2062             inner: ConstantItem(Constant {
2063                 type_: self.type_.clean(cx),
2064                 expr: self.expr.span.to_src(cx),
2065             }),
2066         }
2067     }
2068 }
2069
2070 #[derive(Show, Clone, RustcEncodable, RustcDecodable, PartialEq, Copy)]
2071 pub enum Mutability {
2072     Mutable,
2073     Immutable,
2074 }
2075
2076 impl Clean<Mutability> for ast::Mutability {
2077     fn clean(&self, _: &DocContext) -> Mutability {
2078         match self {
2079             &ast::MutMutable => Mutable,
2080             &ast::MutImmutable => Immutable,
2081         }
2082     }
2083 }
2084
2085 #[derive(Clone, RustcEncodable, RustcDecodable)]
2086 pub struct Impl {
2087     pub generics: Generics,
2088     pub trait_: Option<Type>,
2089     pub for_: Type,
2090     pub items: Vec<Item>,
2091     pub derived: bool,
2092 }
2093
2094 fn detect_derived<M: AttrMetaMethods>(attrs: &[M]) -> bool {
2095     attr::contains_name(attrs, "automatically_derived")
2096 }
2097
2098 impl Clean<Item> for doctree::Impl {
2099     fn clean(&self, cx: &DocContext) -> Item {
2100         Item {
2101             name: None,
2102             attrs: self.attrs.clean(cx),
2103             source: self.whence.clean(cx),
2104             def_id: ast_util::local_def(self.id),
2105             visibility: self.vis.clean(cx),
2106             stability: self.stab.clean(cx),
2107             inner: ImplItem(Impl {
2108                 generics: self.generics.clean(cx),
2109                 trait_: self.trait_.clean(cx),
2110                 for_: self.for_.clean(cx),
2111                 items: self.items.clean(cx).into_iter().map(|ti| {
2112                         match ti {
2113                             MethodImplItem(i) => i,
2114                             TypeImplItem(i) => i,
2115                         }
2116                     }).collect(),
2117                 derived: detect_derived(self.attrs.as_slice()),
2118             }),
2119         }
2120     }
2121 }
2122
2123 #[derive(Clone, RustcEncodable, RustcDecodable)]
2124 pub struct ViewItem {
2125     pub inner: ViewItemInner,
2126 }
2127
2128 impl Clean<Vec<Item>> for ast::ViewItem {
2129     fn clean(&self, cx: &DocContext) -> Vec<Item> {
2130         // We consider inlining the documentation of `pub use` statements, but we
2131         // forcefully don't inline if this is not public or if the
2132         // #[doc(no_inline)] attribute is present.
2133         let denied = self.vis != ast::Public || self.attrs.iter().any(|a| {
2134             a.name().get() == "doc" && match a.meta_item_list() {
2135                 Some(l) => attr::contains_name(l, "no_inline"),
2136                 None => false,
2137             }
2138         });
2139         let convert = |&: node: &ast::ViewItem_| {
2140             Item {
2141                 name: None,
2142                 attrs: self.attrs.clean(cx),
2143                 source: self.span.clean(cx),
2144                 def_id: ast_util::local_def(0),
2145                 visibility: self.vis.clean(cx),
2146                 stability: None,
2147                 inner: ViewItemItem(ViewItem { inner: node.clean(cx) }),
2148             }
2149         };
2150         let mut ret = Vec::new();
2151         match self.node {
2152             ast::ViewItemUse(ref path) if !denied => {
2153                 match path.node {
2154                     ast::ViewPathGlob(..) => ret.push(convert(&self.node)),
2155                     ast::ViewPathList(ref a, ref list, ref b) => {
2156                         // Attempt to inline all reexported items, but be sure
2157                         // to keep any non-inlineable reexports so they can be
2158                         // listed in the documentation.
2159                         let remaining = list.iter().filter(|path| {
2160                             match inline::try_inline(cx, path.node.id(), None) {
2161                                 Some(items) => {
2162                                     ret.extend(items.into_iter()); false
2163                                 }
2164                                 None => true,
2165                             }
2166                         }).map(|a| a.clone()).collect::<Vec<ast::PathListItem>>();
2167                         if remaining.len() > 0 {
2168                             let path = ast::ViewPathList(a.clone(),
2169                                                          remaining,
2170                                                          b.clone());
2171                             let path = syntax::codemap::dummy_spanned(path);
2172                             ret.push(convert(&ast::ViewItemUse(P(path))));
2173                         }
2174                     }
2175                     ast::ViewPathSimple(ident, _, id) => {
2176                         match inline::try_inline(cx, id, Some(ident)) {
2177                             Some(items) => ret.extend(items.into_iter()),
2178                             None => ret.push(convert(&self.node)),
2179                         }
2180                     }
2181                 }
2182             }
2183             ref n => ret.push(convert(n)),
2184         }
2185         return ret;
2186     }
2187 }
2188
2189 #[derive(Clone, RustcEncodable, RustcDecodable)]
2190 pub enum ViewItemInner {
2191     ExternCrate(String, Option<String>, ast::NodeId),
2192     Import(ViewPath)
2193 }
2194
2195 impl Clean<ViewItemInner> for ast::ViewItem_ {
2196     fn clean(&self, cx: &DocContext) -> ViewItemInner {
2197         match self {
2198             &ast::ViewItemExternCrate(ref i, ref p, ref id) => {
2199                 let string = match *p {
2200                     None => None,
2201                     Some((ref x, _)) => Some(x.get().to_string()),
2202                 };
2203                 ExternCrate(i.clean(cx), string, *id)
2204             }
2205             &ast::ViewItemUse(ref vp) => {
2206                 Import(vp.clean(cx))
2207             }
2208         }
2209     }
2210 }
2211
2212 #[derive(Clone, RustcEncodable, RustcDecodable)]
2213 pub enum ViewPath {
2214     // use source as str;
2215     SimpleImport(String, ImportSource),
2216     // use source::*;
2217     GlobImport(ImportSource),
2218     // use source::{a, b, c};
2219     ImportList(ImportSource, Vec<ViewListIdent>),
2220 }
2221
2222 #[derive(Clone, RustcEncodable, RustcDecodable)]
2223 pub struct ImportSource {
2224     pub path: Path,
2225     pub did: Option<ast::DefId>,
2226 }
2227
2228 impl Clean<ViewPath> for ast::ViewPath {
2229     fn clean(&self, cx: &DocContext) -> ViewPath {
2230         match self.node {
2231             ast::ViewPathSimple(ref i, ref p, id) =>
2232                 SimpleImport(i.clean(cx), resolve_use_source(cx, p.clean(cx), id)),
2233             ast::ViewPathGlob(ref p, id) =>
2234                 GlobImport(resolve_use_source(cx, p.clean(cx), id)),
2235             ast::ViewPathList(ref p, ref pl, id) => {
2236                 ImportList(resolve_use_source(cx, p.clean(cx), id),
2237                            pl.clean(cx))
2238             }
2239         }
2240     }
2241 }
2242
2243 #[derive(Clone, RustcEncodable, RustcDecodable)]
2244 pub struct ViewListIdent {
2245     pub name: String,
2246     pub source: Option<ast::DefId>,
2247 }
2248
2249 impl Clean<ViewListIdent> for ast::PathListItem {
2250     fn clean(&self, cx: &DocContext) -> ViewListIdent {
2251         match self.node {
2252             ast::PathListIdent { id, name } => ViewListIdent {
2253                 name: name.clean(cx),
2254                 source: resolve_def(cx, id)
2255             },
2256             ast::PathListMod { id } => ViewListIdent {
2257                 name: "mod".to_string(),
2258                 source: resolve_def(cx, id)
2259             }
2260         }
2261     }
2262 }
2263
2264 impl Clean<Vec<Item>> for ast::ForeignMod {
2265     fn clean(&self, cx: &DocContext) -> Vec<Item> {
2266         self.items.clean(cx)
2267     }
2268 }
2269
2270 impl Clean<Item> for ast::ForeignItem {
2271     fn clean(&self, cx: &DocContext) -> Item {
2272         let inner = match self.node {
2273             ast::ForeignItemFn(ref decl, ref generics) => {
2274                 ForeignFunctionItem(Function {
2275                     decl: decl.clean(cx),
2276                     generics: generics.clean(cx),
2277                     unsafety: ast::Unsafety::Unsafe,
2278                 })
2279             }
2280             ast::ForeignItemStatic(ref ty, mutbl) => {
2281                 ForeignStaticItem(Static {
2282                     type_: ty.clean(cx),
2283                     mutability: if mutbl {Mutable} else {Immutable},
2284                     expr: "".to_string(),
2285                 })
2286             }
2287         };
2288         Item {
2289             name: Some(self.ident.clean(cx)),
2290             attrs: self.attrs.clean(cx),
2291             source: self.span.clean(cx),
2292             def_id: ast_util::local_def(self.id),
2293             visibility: self.vis.clean(cx),
2294             stability: get_stability(cx, ast_util::local_def(self.id)),
2295             inner: inner,
2296         }
2297     }
2298 }
2299
2300 // Utilities
2301
2302 trait ToSource {
2303     fn to_src(&self, cx: &DocContext) -> String;
2304 }
2305
2306 impl ToSource for syntax::codemap::Span {
2307     fn to_src(&self, cx: &DocContext) -> String {
2308         debug!("converting span {:?} to snippet", self.clean(cx));
2309         let sn = match cx.sess().codemap().span_to_snippet(*self) {
2310             Some(x) => x.to_string(),
2311             None    => "".to_string()
2312         };
2313         debug!("got snippet {}", sn);
2314         sn
2315     }
2316 }
2317
2318 fn lit_to_string(lit: &ast::Lit) -> String {
2319     match lit.node {
2320         ast::LitStr(ref st, _) => st.get().to_string(),
2321         ast::LitBinary(ref data) => format!("{:?}", data),
2322         ast::LitByte(b) => {
2323             let mut res = String::from_str("b'");
2324             for c in (b as char).escape_default() {
2325                 res.push(c);
2326             }
2327             res.push('\'');
2328             res
2329         },
2330         ast::LitChar(c) => format!("'{}'", c),
2331         ast::LitInt(i, _t) => i.to_string(),
2332         ast::LitFloat(ref f, _t) => f.get().to_string(),
2333         ast::LitFloatUnsuffixed(ref f) => f.get().to_string(),
2334         ast::LitBool(b) => b.to_string(),
2335     }
2336 }
2337
2338 fn name_from_pat(p: &ast::Pat) -> String {
2339     use syntax::ast::*;
2340     debug!("Trying to get a name from pattern: {:?}", p);
2341
2342     match p.node {
2343         PatWild(PatWildSingle) => "_".to_string(),
2344         PatWild(PatWildMulti) => "..".to_string(),
2345         PatIdent(_, ref p, _) => token::get_ident(p.node).get().to_string(),
2346         PatEnum(ref p, _) => path_to_string(p),
2347         PatStruct(ref name, ref fields, etc) => {
2348             format!("{} {{ {}{} }}", path_to_string(name),
2349                 fields.iter().map(|&Spanned { node: ref fp, .. }|
2350                                   format!("{}: {}", fp.ident.as_str(), name_from_pat(&*fp.pat)))
2351                              .collect::<Vec<String>>().connect(", "),
2352                 if etc { ", ..." } else { "" }
2353             )
2354         },
2355         PatTup(ref elts) => format!("({})", elts.iter().map(|p| name_from_pat(&**p))
2356                                             .collect::<Vec<String>>().connect(", ")),
2357         PatBox(ref p) => name_from_pat(&**p),
2358         PatRegion(ref p, _) => name_from_pat(&**p),
2359         PatLit(..) => {
2360             warn!("tried to get argument name from PatLit, \
2361                   which is silly in function arguments");
2362             "()".to_string()
2363         },
2364         PatRange(..) => panic!("tried to get argument name from PatRange, \
2365                               which is not allowed in function arguments"),
2366         PatVec(ref begin, ref mid, ref end) => {
2367             let begin = begin.iter().map(|p| name_from_pat(&**p));
2368             let mid = mid.as_ref().map(|p| format!("..{}", name_from_pat(&**p))).into_iter();
2369             let end = end.iter().map(|p| name_from_pat(&**p));
2370             format!("[{}]", begin.chain(mid).chain(end).collect::<Vec<_>>().connect(", "))
2371         },
2372         PatMac(..) => {
2373             warn!("can't document the name of a function argument \
2374                    produced by a pattern macro");
2375             "(argument produced by macro)".to_string()
2376         }
2377     }
2378 }
2379
2380 /// Given a Type, resolve it using the def_map
2381 fn resolve_type(cx: &DocContext,
2382                 path: Path,
2383                 id: ast::NodeId) -> Type {
2384     let tcx = match cx.tcx_opt() {
2385         Some(tcx) => tcx,
2386         // If we're extracting tests, this return value doesn't matter.
2387         None => return Primitive(Bool),
2388     };
2389     debug!("searching for {} in defmap", id);
2390     let def = match tcx.def_map.borrow().get(&id) {
2391         Some(&k) => k,
2392         None => panic!("unresolved id not in defmap")
2393     };
2394
2395     match def {
2396         def::DefSelfTy(..) => {
2397             return Generic(token::get_name(special_idents::type_self.name).to_string());
2398         }
2399         def::DefPrimTy(p) => match p {
2400             ast::TyStr => return Primitive(Str),
2401             ast::TyBool => return Primitive(Bool),
2402             ast::TyChar => return Primitive(Char),
2403             ast::TyInt(ast::TyIs(_)) => return Primitive(Isize),
2404             ast::TyInt(ast::TyI8) => return Primitive(I8),
2405             ast::TyInt(ast::TyI16) => return Primitive(I16),
2406             ast::TyInt(ast::TyI32) => return Primitive(I32),
2407             ast::TyInt(ast::TyI64) => return Primitive(I64),
2408             ast::TyUint(ast::TyUs(_)) => return Primitive(Usize),
2409             ast::TyUint(ast::TyU8) => return Primitive(U8),
2410             ast::TyUint(ast::TyU16) => return Primitive(U16),
2411             ast::TyUint(ast::TyU32) => return Primitive(U32),
2412             ast::TyUint(ast::TyU64) => return Primitive(U64),
2413             ast::TyFloat(ast::TyF32) => return Primitive(F32),
2414             ast::TyFloat(ast::TyF64) => return Primitive(F64),
2415         },
2416         def::DefTyParam(_, _, _, n) => return Generic(token::get_name(n).to_string()),
2417         def::DefTyParamBinder(i) => return TyParamBinder(i),
2418         _ => {}
2419     };
2420     let did = register_def(&*cx, def);
2421     ResolvedPath { path: path, typarams: None, did: did }
2422 }
2423
2424 fn register_def(cx: &DocContext, def: def::Def) -> ast::DefId {
2425     let (did, kind) = match def {
2426         def::DefFn(i, _) => (i, TypeFunction),
2427         def::DefTy(i, false) => (i, TypeTypedef),
2428         def::DefTy(i, true) => (i, TypeEnum),
2429         def::DefTrait(i) => (i, TypeTrait),
2430         def::DefStruct(i) => (i, TypeStruct),
2431         def::DefMod(i) => (i, TypeModule),
2432         def::DefStatic(i, _) => (i, TypeStatic),
2433         def::DefVariant(i, _, _) => (i, TypeEnum),
2434         _ => return def.def_id()
2435     };
2436     if ast_util::is_local(did) { return did }
2437     let tcx = match cx.tcx_opt() {
2438         Some(tcx) => tcx,
2439         None => return did
2440     };
2441     inline::record_extern_fqn(cx, did, kind);
2442     if let TypeTrait = kind {
2443         let t = inline::build_external_trait(cx, tcx, did);
2444         cx.external_traits.borrow_mut().as_mut().unwrap().insert(did, t);
2445     }
2446     return did;
2447 }
2448
2449 fn resolve_use_source(cx: &DocContext, path: Path, id: ast::NodeId) -> ImportSource {
2450     ImportSource {
2451         path: path,
2452         did: resolve_def(cx, id),
2453     }
2454 }
2455
2456 fn resolve_def(cx: &DocContext, id: ast::NodeId) -> Option<ast::DefId> {
2457     cx.tcx_opt().and_then(|tcx| {
2458         tcx.def_map.borrow().get(&id).map(|&def| register_def(cx, def))
2459     })
2460 }
2461
2462 #[derive(Clone, RustcEncodable, RustcDecodable)]
2463 pub struct Macro {
2464     pub source: String,
2465 }
2466
2467 impl Clean<Item> for doctree::Macro {
2468     fn clean(&self, cx: &DocContext) -> Item {
2469         Item {
2470             name: Some(format!("{}!", self.name.clean(cx))),
2471             attrs: self.attrs.clean(cx),
2472             source: self.whence.clean(cx),
2473             visibility: ast::Public.clean(cx),
2474             stability: self.stab.clean(cx),
2475             def_id: ast_util::local_def(self.id),
2476             inner: MacroItem(Macro {
2477                 source: self.whence.to_src(cx),
2478             }),
2479         }
2480     }
2481 }
2482
2483 #[derive(Clone, RustcEncodable, RustcDecodable)]
2484 pub struct Stability {
2485     pub level: attr::StabilityLevel,
2486     pub text: String
2487 }
2488
2489 impl Clean<Stability> for attr::Stability {
2490     fn clean(&self, _: &DocContext) -> Stability {
2491         Stability {
2492             level: self.level,
2493             text: self.text.as_ref().map_or("".to_string(),
2494                                             |interned| interned.get().to_string()),
2495         }
2496     }
2497 }
2498
2499 impl Clean<Item> for ast::AssociatedType {
2500     fn clean(&self, cx: &DocContext) -> Item {
2501         Item {
2502             source: self.ty_param.span.clean(cx),
2503             name: Some(self.ty_param.ident.clean(cx)),
2504             attrs: self.attrs.clean(cx),
2505             inner: AssociatedTypeItem(self.ty_param.clean(cx)),
2506             visibility: None,
2507             def_id: ast_util::local_def(self.ty_param.id),
2508             stability: None,
2509         }
2510     }
2511 }
2512
2513 impl Clean<Item> for ty::AssociatedType {
2514     fn clean(&self, cx: &DocContext) -> Item {
2515         Item {
2516             source: DUMMY_SP.clean(cx),
2517             name: Some(self.name.clean(cx)),
2518             attrs: Vec::new(),
2519             // FIXME(#18048): this is wrong, but cross-crate associated types are broken
2520             // anyway, for the time being.
2521             inner: AssociatedTypeItem(TyParam {
2522                 name: self.name.clean(cx),
2523                 did: ast::DefId {
2524                     krate: 0,
2525                     node: ast::DUMMY_NODE_ID
2526                 },
2527                 bounds: vec![],
2528                 default: None,
2529             }),
2530             visibility: None,
2531             def_id: self.def_id,
2532             stability: None,
2533         }
2534     }
2535 }
2536
2537 impl Clean<Item> for ast::Typedef {
2538     fn clean(&self, cx: &DocContext) -> Item {
2539         Item {
2540             source: self.span.clean(cx),
2541             name: Some(self.ident.clean(cx)),
2542             attrs: self.attrs.clean(cx),
2543             inner: TypedefItem(Typedef {
2544                 type_: self.typ.clean(cx),
2545                 generics: Generics {
2546                     lifetimes: Vec::new(),
2547                     type_params: Vec::new(),
2548                     where_predicates: Vec::new()
2549                 },
2550             }),
2551             visibility: None,
2552             def_id: ast_util::local_def(self.id),
2553             stability: None,
2554         }
2555     }
2556 }
2557
2558 fn lang_struct(cx: &DocContext, did: Option<ast::DefId>,
2559                t: ty::Ty, name: &str,
2560                fallback: fn(Box<Type>) -> Type) -> Type {
2561     let did = match did {
2562         Some(did) => did,
2563         None => return fallback(box t.clean(cx)),
2564     };
2565     let fqn = csearch::get_item_path(cx.tcx(), did);
2566     let fqn: Vec<String> = fqn.into_iter().map(|i| {
2567         i.to_string()
2568     }).collect();
2569     cx.external_paths.borrow_mut().as_mut().unwrap().insert(did, (fqn, TypeStruct));
2570     ResolvedPath {
2571         typarams: None,
2572         did: did,
2573         path: Path {
2574             global: false,
2575             segments: vec![PathSegment {
2576                 name: name.to_string(),
2577                 params: PathParameters::AngleBracketed {
2578                     lifetimes: vec![],
2579                     types: vec![t.clean(cx)],
2580                     bindings: vec![]
2581                 }
2582             }],
2583         },
2584     }
2585 }
2586
2587 /// An equality constraint on an associated type, e.g. `A=Bar` in `Foo<A=Bar>`
2588 #[derive(Clone, PartialEq, RustcDecodable, RustcEncodable, Show)]
2589 pub struct TypeBinding {
2590     pub name: String,
2591     pub ty: Type
2592 }
2593
2594 impl Clean<TypeBinding> for ast::TypeBinding {
2595     fn clean(&self, cx: &DocContext) -> TypeBinding {
2596         TypeBinding {
2597             name: self.ident.clean(cx),
2598             ty: self.ty.clean(cx)
2599         }
2600     }
2601 }