src/librustdoc/html/format.rs

   1 // Copyright 2013-2014 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 //! HTML formatting module
  12 //!
  13 //! This module contains a large number of `fmt::Display` implementations for
  14 //! various types in `rustdoc::clean`. These implementations all currently
  15 //! assume that HTML output is desired, although it may be possible to redesign
  16 //! them in the future to instead emit any format desired.
  17
  18 use std::fmt;
  19 use std::iter::repeat;
  20
  21 use rustc::middle::cstore::LOCAL_CRATE;
  22 use rustc::middle::def_id::{CRATE_DEF_INDEX, DefId};
  23 use syntax::abi::Abi;
  24 use rustc_front::hir;
  25
  26 use clean;
  27 use html::item_type::ItemType;
  28 use html::render;
  29 use html::render::{cache, CURRENT_LOCATION_KEY};
  30
  31 /// Helper to render an optional visibility with a space after it (if the
  32 /// visibility is preset)
  33 #[derive(Copy, Clone)]
  34 pub struct VisSpace(pub Option<hir::Visibility>);
  35 /// Similarly to VisSpace, this structure is used to render a function style with a
  36 /// space after it.
  37 #[derive(Copy, Clone)]
  38 pub struct UnsafetySpace(pub hir::Unsafety);
  39 /// Similarly to VisSpace, this structure is used to render a function constness
  40 /// with a space after it.
  41 #[derive(Copy, Clone)]
  42 pub struct ConstnessSpace(pub hir::Constness);
  43 /// Wrapper struct for properly emitting a method declaration.
  44 pub struct Method<'a>(pub &'a clean::SelfTy, pub &'a clean::FnDecl);
  45 /// Similar to VisSpace, but used for mutability
  46 #[derive(Copy, Clone)]
  47 pub struct MutableSpace(pub clean::Mutability);
  48 /// Similar to VisSpace, but used for mutability
  49 #[derive(Copy, Clone)]
  50 pub struct RawMutableSpace(pub clean::Mutability);
  51 /// Wrapper struct for emitting a where clause from Generics.
  52 pub struct WhereClause<'a>(pub &'a clean::Generics);
  53 /// Wrapper struct for emitting type parameter bounds.
  54 pub struct TyParamBounds<'a>(pub &'a [clean::TyParamBound]);
  55 /// Wrapper struct for emitting a comma-separated list of items
  56 pub struct CommaSep<'a, T: 'a>(pub &'a [T]);
  57 pub struct AbiSpace(pub Abi);
  58
  59 impl VisSpace {
  60     pub fn get(&self) -> Option<hir::Visibility> {
  61         let VisSpace(v) = *self; v
  62     }
  63 }
  64
  65 impl UnsafetySpace {
  66     pub fn get(&self) -> hir::Unsafety {
  67         let UnsafetySpace(v) = *self; v
  68     }
  69 }
  70
  71 impl ConstnessSpace {
  72     pub fn get(&self) -> hir::Constness {
  73         let ConstnessSpace(v) = *self; v
  74     }
  75 }
  76
  77 impl<'a, T: fmt::Display> fmt::Display for CommaSep<'a, T> {
  78     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  79         for (i, item) in self.0.iter().enumerate() {
  80             if i != 0 { try!(write!(f, ", ")); }
  81             try!(write!(f, "{}", item));
  82         }
  83         Ok(())
  84     }
  85 }
  86
  87 impl<'a> fmt::Display for TyParamBounds<'a> {
  88     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  89         let &TyParamBounds(bounds) = self;
  90         for (i, bound) in bounds.iter().enumerate() {
  91             if i > 0 {
  92                 try!(f.write_str(" + "));
  93             }
  94             try!(write!(f, "{}", *bound));
  95         }
  96         Ok(())
  97     }
  98 }
  99
 100 impl fmt::Display for clean::Generics {
 101     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 102         if self.lifetimes.is_empty() && self.type_params.is_empty() { return Ok(()) }
 103         try!(f.write_str("&lt;"));
 104
 105         for (i, life) in self.lifetimes.iter().enumerate() {
 106             if i > 0 {
 107                 try!(f.write_str(", "));
 108             }
 109             try!(write!(f, "{}", *life));
 110         }
 111
 112         if !self.type_params.is_empty() {
 113             if !self.lifetimes.is_empty() {
 114                 try!(f.write_str(", "));
 115             }
 116             for (i, tp) in self.type_params.iter().enumerate() {
 117                 if i > 0 {
 118                     try!(f.write_str(", "))
 119                 }
 120                 try!(f.write_str(&tp.name));
 121
 122                 if !tp.bounds.is_empty() {
 123                     try!(write!(f, ": {}", TyParamBounds(&tp.bounds)));
 124                 }
 125
 126                 match tp.default {
 127                     Some(ref ty) => { try!(write!(f, " = {}", ty)); },
 128                     None => {}
 129                 };
 130             }
 131         }
 132         try!(f.write_str("&gt;"));
 133         Ok(())
 134     }
 135 }
 136
 137 impl<'a> fmt::Display for WhereClause<'a> {
 138     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 139         let &WhereClause(gens) = self;
 140         if gens.where_predicates.is_empty() {
 141             return Ok(());
 142         }
 143         try!(f.write_str(" <span class='where'>where "));
 144         for (i, pred) in gens.where_predicates.iter().enumerate() {
 145             if i > 0 {
 146                 try!(f.write_str(", "));
 147             }
 148             match pred {
 149                 &clean::WherePredicate::BoundPredicate { ref ty, ref bounds } => {
 150                     let bounds = bounds;
 151                     try!(write!(f, "{}: {}", ty, TyParamBounds(bounds)));
 152                 }
 153                 &clean::WherePredicate::RegionPredicate { ref lifetime,
 154                                                           ref bounds } => {
 155                     try!(write!(f, "{}: ", lifetime));
 156                     for (i, lifetime) in bounds.iter().enumerate() {
 157                         if i > 0 {
 158                             try!(f.write_str(" + "));
 159                         }
 160
 161                         try!(write!(f, "{}", lifetime));
 162                     }
 163                 }
 164                 &clean::WherePredicate::EqPredicate { ref lhs, ref rhs } => {
 165                     try!(write!(f, "{} == {}", lhs, rhs));
 166                 }
 167             }
 168         }
 169         try!(f.write_str("</span>"));
 170         Ok(())
 171     }
 172 }
 173
 174 impl fmt::Display for clean::Lifetime {
 175     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 176         try!(f.write_str(self.get_ref()));
 177         Ok(())
 178     }
 179 }
 180
 181 impl fmt::Display for clean::PolyTrait {
 182     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 183         if !self.lifetimes.is_empty() {
 184             try!(f.write_str("for&lt;"));
 185             for (i, lt) in self.lifetimes.iter().enumerate() {
 186                 if i > 0 {
 187                     try!(f.write_str(", "));
 188                 }
 189                 try!(write!(f, "{}", lt));
 190             }
 191             try!(f.write_str("&gt; "));
 192         }
 193         write!(f, "{}", self.trait_)
 194     }
 195 }
 196
 197 impl fmt::Display for clean::TyParamBound {
 198     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 199         match *self {
 200             clean::RegionBound(ref lt) => {
 201                 write!(f, "{}", *lt)
 202             }
 203             clean::TraitBound(ref ty, modifier) => {
 204                 let modifier_str = match modifier {
 205                     hir::TraitBoundModifier::None => "",
 206                     hir::TraitBoundModifier::Maybe => "?",
 207                 };
 208                 write!(f, "{}{}", modifier_str, *ty)
 209             }
 210         }
 211     }
 212 }
 213
 214 impl fmt::Display for clean::PathParameters {
 215     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 216         match *self {
 217             clean::PathParameters::AngleBracketed {
 218                 ref lifetimes, ref types, ref bindings
 219             } => {
 220                 if !lifetimes.is_empty() || !types.is_empty() || !bindings.is_empty() {
 221                     try!(f.write_str("&lt;"));
 222                     let mut comma = false;
 223                     for lifetime in lifetimes {
 224                         if comma {
 225                             try!(f.write_str(", "));
 226                         }
 227                         comma = true;
 228                         try!(write!(f, "{}", *lifetime));
 229                     }
 230                     for ty in types {
 231                         if comma {
 232                             try!(f.write_str(", "));
 233                         }
 234                         comma = true;
 235                         try!(write!(f, "{}", *ty));
 236                     }
 237                     for binding in bindings {
 238                         if comma {
 239                             try!(f.write_str(", "));
 240                         }
 241                         comma = true;
 242                         try!(write!(f, "{}", *binding));
 243                     }
 244                     try!(f.write_str("&gt;"));
 245                 }
 246             }
 247             clean::PathParameters::Parenthesized { ref inputs, ref output } => {
 248                 try!(f.write_str("("));
 249                 let mut comma = false;
 250                 for ty in inputs {
 251                     if comma {
 252                         try!(f.write_str(", "));
 253                     }
 254                     comma = true;
 255                     try!(write!(f, "{}", *ty));
 256                 }
 257                 try!(f.write_str(")"));
 258                 if let Some(ref ty) = *output {
 259                     try!(f.write_str(" -&gt; "));
 260                     try!(write!(f, "{}", ty));
 261                 }
 262             }
 263         }
 264         Ok(())
 265     }
 266 }
 267
 268 impl fmt::Display for clean::PathSegment {
 269     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 270         try!(f.write_str(&self.name));
 271         write!(f, "{}", self.params)
 272     }
 273 }
 274
 275 impl fmt::Display for clean::Path {
 276     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 277         if self.global {
 278             try!(f.write_str("::"))
 279         }
 280
 281         for (i, seg) in self.segments.iter().enumerate() {
 282             if i > 0 {
 283                 try!(f.write_str("::"))
 284             }
 285             try!(write!(f, "{}", seg));
 286         }
 287         Ok(())
 288     }
 289 }
 290
 291 pub fn href(did: DefId) -> Option<(String, ItemType, Vec<String>)> {
 292     let cache = cache();
 293     let loc = CURRENT_LOCATION_KEY.with(|l| l.borrow().clone());
 294     let &(ref fqp, shortty) = match cache.paths.get(&did) {
 295         Some(p) => p,
 296         None => return None,
 297     };
 298     let mut url = if did.is_local() || cache.inlined.contains(&did) {
 299         repeat("../").take(loc.len()).collect::<String>()
 300     } else {
 301         match cache.extern_locations[&did.krate] {
 302             (_, render::Remote(ref s)) => s.to_string(),
 303             (_, render::Local) => repeat("../").take(loc.len()).collect(),
 304             (_, render::Unknown) => return None,
 305         }
 306     };
 307     for component in &fqp[..fqp.len() - 1] {
 308         url.push_str(component);
 309         url.push_str("/");
 310     }
 311     match shortty {
 312         ItemType::Module => {
 313             url.push_str(fqp.last().unwrap());
 314             url.push_str("/index.html");
 315         }
 316         _ => {
 317             url.push_str(shortty.to_static_str());
 318             url.push_str(".");
 319             url.push_str(fqp.last().unwrap());
 320             url.push_str(".html");
 321         }
 322     }
 323     Some((url, shortty, fqp.to_vec()))
 324 }
 325
 326 /// Used when rendering a `ResolvedPath` structure. This invokes the `path`
 327 /// rendering function with the necessary arguments for linking to a local path.
 328 fn resolved_path(w: &mut fmt::Formatter, did: DefId, path: &clean::Path,
 329                  print_all: bool) -> fmt::Result {
 330     let last = path.segments.last().unwrap();
 331     let rel_root = match &*path.segments[0].name {
 332         "self" => Some("./".to_string()),
 333         _ => None,
 334     };
 335
 336     if print_all {
 337         let amt = path.segments.len() - 1;
 338         match rel_root {
 339             Some(mut root) => {
 340                 for seg in &path.segments[..amt] {
 341                     if "super" == seg.name || "self" == seg.name {
 342                         try!(write!(w, "{}::", seg.name));
 343                     } else {
 344                         root.push_str(&seg.name);
 345                         root.push_str("/");
 346                         try!(write!(w, "<a class='mod'
 347                                             href='{}index.html'>{}</a>::",
 348                                       root,
 349                                       seg.name));
 350                     }
 351                 }
 352             }
 353             None => {
 354                 for seg in &path.segments[..amt] {
 355                     try!(write!(w, "{}::", seg.name));
 356                 }
 357             }
 358         }
 359     }
 360
 361     match href(did) {
 362         Some((url, shortty, fqp)) => {
 363             try!(write!(w, "<a class='{}' href='{}' title='{}'>{}</a>",
 364                           shortty, url, fqp.join("::"), last.name));
 365         }
 366         _ => try!(write!(w, "{}", last.name)),
 367     }
 368     try!(write!(w, "{}", last.params));
 369     Ok(())
 370 }
 371
 372 fn primitive_link(f: &mut fmt::Formatter,
 373                   prim: clean::PrimitiveType,
 374                   name: &str) -> fmt::Result {
 375     let m = cache();
 376     let mut needs_termination = false;
 377     match m.primitive_locations.get(&prim) {
 378         Some(&LOCAL_CRATE) => {
 379             let len = CURRENT_LOCATION_KEY.with(|s| s.borrow().len());
 380             let len = if len == 0 {0} else {len - 1};
 381             try!(write!(f, "<a class='primitive' href='{}primitive.{}.html'>",
 382                         repeat("../").take(len).collect::<String>(),
 383                         prim.to_url_str()));
 384             needs_termination = true;
 385         }
 386         Some(&cnum) => {
 387             let path = &m.paths[&DefId {
 388                 krate: cnum,
 389                 index: CRATE_DEF_INDEX,
 390             }];
 391             let loc = match m.extern_locations[&cnum] {
 392                 (_, render::Remote(ref s)) => Some(s.to_string()),
 393                 (_, render::Local) => {
 394                     let len = CURRENT_LOCATION_KEY.with(|s| s.borrow().len());
 395                     Some(repeat("../").take(len).collect::<String>())
 396                 }
 397                 (_, render::Unknown) => None,
 398             };
 399             match loc {
 400                 Some(root) => {
 401                     try!(write!(f, "<a class='primitive' href='{}{}/primitive.{}.html'>",
 402                                 root,
 403                                 path.0.first().unwrap(),
 404                                 prim.to_url_str()));
 405                     needs_termination = true;
 406                 }
 407                 None => {}
 408             }
 409         }
 410         None => {}
 411     }
 412     try!(write!(f, "{}", name));
 413     if needs_termination {
 414         try!(write!(f, "</a>"));
 415     }
 416     Ok(())
 417 }
 418
 419 /// Helper to render type parameters
 420 fn tybounds(w: &mut fmt::Formatter,
 421             typarams: &Option<Vec<clean::TyParamBound> >) -> fmt::Result {
 422     match *typarams {
 423         Some(ref params) => {
 424             for param in params {
 425                 try!(write!(w, " + "));
 426                 try!(write!(w, "{}", *param));
 427             }
 428             Ok(())
 429         }
 430         None => Ok(())
 431     }
 432 }
 433
 434 impl fmt::Display for clean::Type {
 435     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 436         match *self {
 437             clean::Generic(ref name) => {
 438                 f.write_str(name)
 439             }
 440             clean::ResolvedPath{ did, ref typarams, ref path, is_generic } => {
 441                 // Paths like T::Output and Self::Output should be rendered with all segments
 442                 try!(resolved_path(f, did, path, is_generic));
 443                 tybounds(f, typarams)
 444             }
 445             clean::Infer => write!(f, "_"),
 446             clean::Primitive(prim) => primitive_link(f, prim, prim.to_string()),
 447             clean::BareFunction(ref decl) => {
 448                 write!(f, "{}{}fn{}{}",
 449                        UnsafetySpace(decl.unsafety),
 450                        match &*decl.abi {
 451                            "" => " extern ".to_string(),
 452                            "\"Rust\"" => "".to_string(),
 453                            s => format!(" extern {} ", s)
 454                        },
 455                        decl.generics,
 456                        decl.decl)
 457             }
 458             clean::Tuple(ref typs) => {
 459                 match &**typs {
 460                     [] => primitive_link(f, clean::PrimitiveTuple, "()"),
 461                     [ref one] => {
 462                         try!(primitive_link(f, clean::PrimitiveTuple, "("));
 463                         try!(write!(f, "{},", one));
 464                         primitive_link(f, clean::PrimitiveTuple, ")")
 465                     }
 466                     many => {
 467                         try!(primitive_link(f, clean::PrimitiveTuple, "("));
 468                         try!(write!(f, "{}", CommaSep(&many)));
 469                         primitive_link(f, clean::PrimitiveTuple, ")")
 470                     }
 471                 }
 472             }
 473             clean::Vector(ref t) => {
 474                 try!(primitive_link(f, clean::Slice, &format!("[")));
 475                 try!(write!(f, "{}", t));
 476                 primitive_link(f, clean::Slice, &format!("]"))
 477             }
 478             clean::FixedVector(ref t, ref s) => {
 479                 try!(primitive_link(f, clean::PrimitiveType::Array, "["));
 480                 try!(write!(f, "{}", t));
 481                 primitive_link(f, clean::PrimitiveType::Array,
 482                                &format!("; {}]", *s))
 483             }
 484             clean::Bottom => f.write_str("!"),
 485             clean::RawPointer(m, ref t) => {
 486                 match **t {
 487                     clean::Generic(_) | clean::ResolvedPath {is_generic: true, ..} => {
 488                         primitive_link(f, clean::PrimitiveType::PrimitiveRawPointer,
 489                                        &format!("*{}{}", RawMutableSpace(m), t))
 490                     }
 491                     _ => {
 492                         try!(primitive_link(f, clean::PrimitiveType::PrimitiveRawPointer,
 493                                             &format!("*{}", RawMutableSpace(m))));
 494                         write!(f, "{}", t)
 495                     }
 496                 }
 497             }
 498             clean::BorrowedRef{ lifetime: ref l, mutability, type_: ref ty} => {
 499                 let lt = match *l {
 500                     Some(ref l) => format!("{} ", *l),
 501                     _ => "".to_string(),
 502                 };
 503                 let m = MutableSpace(mutability);
 504                 match **ty {
 505                     clean::Vector(ref bt) => { // BorrowedRef{ ... Vector(T) } is &[T]
 506                         match **bt {
 507                             clean::Generic(_) =>
 508                                 primitive_link(f, clean::Slice,
 509                                     &format!("&amp;{}{}[{}]", lt, m, **bt)),
 510                             _ => {
 511                                 try!(primitive_link(f, clean::Slice,
 512                                     &format!("&amp;{}{}[", lt, m)));
 513                                 try!(write!(f, "{}", **bt));
 514                                 primitive_link(f, clean::Slice, "]")
 515                             }
 516                         }
 517                     }
 518                     _ => {
 519                         write!(f, "&amp;{}{}{}", lt, m, **ty)
 520                     }
 521                 }
 522             }
 523             clean::PolyTraitRef(ref bounds) => {
 524                 for (i, bound) in bounds.iter().enumerate() {
 525                     if i != 0 {
 526                         try!(write!(f, " + "));
 527                     }
 528                     try!(write!(f, "{}", *bound));
 529                 }
 530                 Ok(())
 531             }
 532             // It's pretty unsightly to look at `<A as B>::C` in output, and
 533             // we've got hyperlinking on our side, so try to avoid longer
 534             // notation as much as possible by making `C` a hyperlink to trait
 535             // `B` to disambiguate.
 536             //
 537             // FIXME: this is still a lossy conversion and there should probably
 538             //        be a better way of representing this in general? Most of
 539             //        the ugliness comes from inlining across crates where
 540             //        everything comes in as a fully resolved QPath (hard to
 541             //        look at).
 542             clean::QPath {
 543                 ref name,
 544                 ref self_type,
 545                 trait_: box clean::ResolvedPath { did, ref typarams, .. },
 546             } => {
 547                 try!(write!(f, "{}::", self_type));
 548                 let path = clean::Path::singleton(name.clone());
 549                 try!(resolved_path(f, did, &path, false));
 550
 551                 // FIXME: `typarams` are not rendered, and this seems bad?
 552                 drop(typarams);
 553                 Ok(())
 554             }
 555             clean::QPath { ref name, ref self_type, ref trait_ } => {
 556                 write!(f, "&lt;{} as {}&gt;::{}", self_type, trait_, name)
 557             }
 558             clean::Unique(..) => {
 559                 panic!("should have been cleaned")
 560             }
 561         }
 562     }
 563 }
 564
 565 impl fmt::Display for clean::Impl {
 566     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 567         try!(write!(f, "impl{} ", self.generics));
 568         if let Some(ref ty) = self.trait_ {
 569             try!(write!(f, "{}{} for ",
 570                         if self.polarity == Some(clean::ImplPolarity::Negative) { "!" } else { "" },
 571                         *ty));
 572         }
 573         try!(write!(f, "{}{}", self.for_, WhereClause(&self.generics)));
 574         Ok(())
 575     }
 576 }
 577
 578 impl fmt::Display for clean::Arguments {
 579     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 580         for (i, input) in self.values.iter().enumerate() {
 581             if i > 0 { try!(write!(f, ", ")); }
 582             if !input.name.is_empty() {
 583                 try!(write!(f, "{}: ", input.name));
 584             }
 585             try!(write!(f, "{}", input.type_));
 586         }
 587         Ok(())
 588     }
 589 }
 590
 591 impl fmt::Display for clean::FunctionRetTy {
 592     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 593         match *self {
 594             clean::Return(clean::Tuple(ref tys)) if tys.is_empty() => Ok(()),
 595             clean::Return(ref ty) => write!(f, " -&gt; {}", ty),
 596             clean::DefaultReturn => Ok(()),
 597             clean::NoReturn => write!(f, " -&gt; !")
 598         }
 599     }
 600 }
 601
 602 impl fmt::Display for clean::FnDecl {
 603     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 604         if self.variadic {
 605             write!(f, "({args}, ...){arrow}", args = self.inputs, arrow = self.output)
 606         } else {
 607             write!(f, "({args}){arrow}", args = self.inputs, arrow = self.output)
 608         }
 609     }
 610 }
 611
 612 impl<'a> fmt::Display for Method<'a> {
 613     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 614         let Method(selfty, d) = *self;
 615         let mut args = String::new();
 616         match *selfty {
 617             clean::SelfStatic => {},
 618             clean::SelfValue => args.push_str("self"),
 619             clean::SelfBorrowed(Some(ref lt), mtbl) => {
 620                 args.push_str(&format!("&amp;{} {}self", *lt, MutableSpace(mtbl)));
 621             }
 622             clean::SelfBorrowed(None, mtbl) => {
 623                 args.push_str(&format!("&amp;{}self", MutableSpace(mtbl)));
 624             }
 625             clean::SelfExplicit(ref typ) => {
 626                 args.push_str(&format!("self: {}", *typ));
 627             }
 628         }
 629         for (i, input) in d.inputs.values.iter().enumerate() {
 630             if i > 0 || !args.is_empty() { args.push_str(", "); }
 631             if !input.name.is_empty() {
 632                 args.push_str(&format!("{}: ", input.name));
 633             }
 634             args.push_str(&format!("{}", input.type_));
 635         }
 636         write!(f, "({args}){arrow}", args = args, arrow = d.output)
 637     }
 638 }
 639
 640 impl fmt::Display for VisSpace {
 641     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 642         match self.get() {
 643             Some(hir::Public) => write!(f, "pub "),
 644             Some(hir::Inherited) | None => Ok(())
 645         }
 646     }
 647 }
 648
 649 impl fmt::Display for UnsafetySpace {
 650     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 651         match self.get() {
 652             hir::Unsafety::Unsafe => write!(f, "unsafe "),
 653             hir::Unsafety::Normal => Ok(())
 654         }
 655     }
 656 }
 657
 658 impl fmt::Display for ConstnessSpace {
 659     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 660         match self.get() {
 661             hir::Constness::Const => write!(f, "const "),
 662             hir::Constness::NotConst => Ok(())
 663         }
 664     }
 665 }
 666
 667 impl fmt::Display for clean::Import {
 668     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 669         match *self {
 670             clean::SimpleImport(ref name, ref src) => {
 671                 if *name == src.path.segments.last().unwrap().name {
 672                     write!(f, "use {};", *src)
 673                 } else {
 674                     write!(f, "use {} as {};", *src, *name)
 675                 }
 676             }
 677             clean::GlobImport(ref src) => {
 678                 write!(f, "use {}::*;", *src)
 679             }
 680             clean::ImportList(ref src, ref names) => {
 681                 try!(write!(f, "use {}::{{", *src));
 682                 for (i, n) in names.iter().enumerate() {
 683                     if i > 0 {
 684                         try!(write!(f, ", "));
 685                     }
 686                     try!(write!(f, "{}", *n));
 687                 }
 688                 write!(f, "}};")
 689             }
 690         }
 691     }
 692 }
 693
 694 impl fmt::Display for clean::ImportSource {
 695     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 696         match self.did {
 697             Some(did) => resolved_path(f, did, &self.path, true),
 698             _ => {
 699                 for (i, seg) in self.path.segments.iter().enumerate() {
 700                     if i > 0 {
 701                         try!(write!(f, "::"))
 702                     }
 703                     try!(write!(f, "{}", seg.name));
 704                 }
 705                 Ok(())
 706             }
 707         }
 708     }
 709 }
 710
 711 impl fmt::Display for clean::ViewListIdent {
 712     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 713         match self.source {
 714             Some(did) => {
 715                 let path = clean::Path::singleton(self.name.clone());
 716                 try!(resolved_path(f, did, &path, false));
 717             }
 718             _ => try!(write!(f, "{}", self.name)),
 719         }
 720
 721         if let Some(ref name) = self.rename {
 722             try!(write!(f, " as {}", name));
 723         }
 724         Ok(())
 725     }
 726 }
 727
 728 impl fmt::Display for clean::TypeBinding {
 729     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 730         write!(f, "{}={}", self.name, self.ty)
 731     }
 732 }
 733
 734 impl fmt::Display for MutableSpace {
 735     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 736         match *self {
 737             MutableSpace(clean::Immutable) => Ok(()),
 738             MutableSpace(clean::Mutable) => write!(f, "mut "),
 739         }
 740     }
 741 }
 742
 743 impl fmt::Display for RawMutableSpace {
 744     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 745         match *self {
 746             RawMutableSpace(clean::Immutable) => write!(f, "const "),
 747             RawMutableSpace(clean::Mutable) => write!(f, "mut "),
 748         }
 749     }
 750 }
 751
 752 impl fmt::Display for AbiSpace {
 753     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 754         match self.0 {
 755             Abi::Rust => Ok(()),
 756             Abi::C => write!(f, "extern "),
 757             abi => write!(f, "extern {} ", abi),
 758         }
 759     }
 760 }