Apply the same transformation to every types

GuillaumeGomez · GuillaumeGomez · commit d06f72d06203 · 2017-02-28T00:27:19.000+01:00
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
@@ -90,6 +90,16 @@ impl<'a, T: fmt::Display> fmt::Display for CommaSep<'a, T> {
     }
 }
 
+impl<'a, T: fmt::Debug> fmt::Debug for CommaSep<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for (i, item) in self.0.iter().enumerate() {
+            if i != 0 { write!(f, ", ")?; }
+            fmt::Debug::fmt(item, f)?;
+        }
+        Ok(())
+    }
+}
+
 impl<'a> fmt::Display for TyParamBounds<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let &TyParamBounds(bounds) = self;
@@ -165,7 +175,7 @@ impl<'a> fmt::Display for WhereClause<'a> {
         if f.alternate() {
             clause.push_str(" where ");
         } else {
-            clause.push_str(" <span class='where fmt-newline'>where ");
+            clause.push_str(" <span class=\"where fmt-newline\">where ");
         }
         for (i, pred) in gens.where_predicates.iter().enumerate() {
             if i > 0 {
@@ -449,8 +459,8 @@ fn resolved_path(w: &mut fmt::Formatter, did: DefId, path: &clean::Path,
                     } else {
                         root.push_str(&seg.name);
                         root.push_str("/");
-                        write!(w, "<a class='mod'
-                                       href='{}index.html'>{}</a>::",
+                        write!(w, "<a class=\"mod\"
+                                       href=\"{}index.html\">{}</a>::",
                                  root,
                                  seg.name)?;
                     }
@@ -491,7 +501,7 @@ fn primitive_link(f: &mut fmt::Formatter,
             Some(&def_id) if def_id.is_local() => {
                 let len = CURRENT_LOCATION_KEY.with(|s| s.borrow().len());
                 let len = if len == 0 {0} else {len - 1};
-                write!(f, "<a class='primitive' href='{}primitive.{}.html'>",
+                write!(f, "<a class=\"primitive\" href=\"{}primitive.{}.html\">",
                        repeat("../").take(len).collect::<String>(),
                        prim.to_url_str())?;
                 needs_termination = true;
@@ -508,7 +518,7 @@ fn primitive_link(f: &mut fmt::Formatter,
                     (.., render::Unknown) => None,
                 };
                 if let Some((cname, root)) = loc {
-                    write!(f, "<a class='primitive' href='{}{}/primitive.{}.html'>",
+                    write!(f, "<a class=\"primitive\" href=\"{}{}/primitive.{}.html\">",
                            root,
                            cname,
                            prim.to_url_str())?;
@@ -550,7 +560,7 @@ impl<'a> fmt::Display for HRef<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match href(self.did) {
             Some((url, shortty, fqp)) => if !f.alternate() {
-                write!(f, "<a class='{}' href='{}' title='{} {}'>{}</a>",
+                write!(f, "<a class=\"{}\" href=\"{}\" title=\"{} {}\">{}</a>",
                        shortty, url, shortty, fqp.join("::"), self.text)
             } else {
                 write!(f, "{}", self.text)
@@ -599,21 +609,21 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,
                     fmt::Display::fmt(one, f)?;
                     primitive_link(f, PrimitiveType::Tuple, ",)")
                 }
-                &[ref one] => write!(f, "({},)", one),
+                &[ref one] => write!(f, "({:?},)", one),
                 many if is_not_debug => {
                     primitive_link(f, PrimitiveType::Tuple, "(")?;
                     fmt::Display::fmt(&CommaSep(&many), f)?;
                     primitive_link(f, PrimitiveType::Tuple, ")")
                 }
-                many => write!(f, "({})", &CommaSep(&many)),
+                many => write!(f, "({:?})", &CommaSep(&many)),
             }
         }
         clean::Vector(ref t) if is_not_debug => {
             primitive_link(f, PrimitiveType::Slice, &format!("["))?;
             fmt::Display::fmt(t, f)?;
             primitive_link(f, PrimitiveType::Slice, &format!("]"))
         }
-        clean::Vector(ref t) => write!(f, "[{}]", t),
+        clean::Vector(ref t) => write!(f, "[{:?}]", t),
         clean::FixedVector(ref t, ref s) if is_not_debug => {
             primitive_link(f, PrimitiveType::Array, "[")?;
             fmt::Display::fmt(t, f)?;
@@ -627,9 +637,9 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,
         }
         clean::FixedVector(ref t, ref s) => {
             if f.alternate() {
-                write!(f, "[{}; {}]", t, s)
+                write!(f, "[{:?}; {}]", t, s)
             } else {
-                write!(f, "[{}; {}]", t, Escape(s))
+                write!(f, "[{:?}; {}]", t, Escape(s))
             }
         }
         clean::Never => f.write_str("!"),
@@ -646,9 +656,9 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,
                 }
                 clean::Generic(_) | clean::ResolvedPath {is_generic: true, ..} => {
                     if f.alternate() {
-                        write!(f, "*{}{:#}", RawMutableSpace(m), t)
+                        write!(f, "*{}{:#?}", RawMutableSpace(m), t)
                     } else {
-                        write!(f, "*{}{}", RawMutableSpace(m), t)
+                        write!(f, "*{}{:?}", RawMutableSpace(m), t)
                     }
                 }
                 _ if is_not_debug => {
@@ -657,7 +667,7 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,
                     fmt::Display::fmt(t, f)
                 }
                 _ => {
-                    write!(f, "*{}{}", RawMutableSpace(m), t)
+                    write!(f, "*{}{:?}", RawMutableSpace(m), t)
                 }
             }
         }
@@ -681,9 +691,9 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,
                         }
                         clean::Generic(_) => {
                             if f.alternate() {
-                                write!(f, "&{}{}[{:#}]", lt, m, **bt)
+                                write!(f, "&{}{}[{:#?}]", lt, m, **bt)
                             } else {
-                                write!(f, "&{}{}[{}]", lt, m, **bt)
+                                write!(f, "&{}{}[{:?}]", lt, m, **bt)
                             }
                         }
                         _ if is_not_debug => {
@@ -700,9 +710,9 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,
                         }
                         _ => {
                             if f.alternate() {
-                                write!(f, "&{}{}[{:#}]", lt, m, **bt)
+                                write!(f, "&{}{}[{:#?}]", lt, m, **bt)
                             } else {
-                                write!(f, "&{}{}[{}]", lt, m, **bt)
+                                write!(f, "&{}{}[{:?}]", lt, m, **bt)
                             }
                         }
                     }
@@ -765,12 +775,16 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,
         }
         clean::QPath { ref name, ref self_type, ref trait_ } => {
             if f.alternate() {
-                write!(f, "<{:#} as {:#}>::{}", self_type, trait_, name)
+                if is_not_debug {
+                    write!(f, "<{:#} as {:#}>::{}", self_type, trait_, name)
+                } else {
+                    write!(f, "<{:#?} as {:#?}>::{}", self_type, trait_, name)
+                }
             } else {
                 if is_not_debug {
                     write!(f, "&lt;{} as {}&gt;::{}", self_type, trait_, name)
                 } else {
-                    write!(f, "<{} as {}>::{}", self_type, trait_, name)
+                    write!(f, "<{:?} as {:?}>::{}", self_type, trait_, name)
                 }
             }
         }
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
@@ -144,12 +144,12 @@ impl<U: Write> Writer for U {
                           -> io::Result<()> {
         match klass {
             Class::None => write!(self, "{}", text),
-            klass => write!(self, "<span class='{}'>{}</span>", klass.rustdoc_class(), text),
+            klass => write!(self, "<span class=\"{}\">{}</span>", klass.rustdoc_class(), text),
         }
     }
 
     fn enter_span(&mut self, klass: Class) -> io::Result<()> {
-        write!(self, "<span class='{}'>", klass.rustdoc_class())
+        write!(self, "<span class=\"{}\">", klass.rustdoc_class())
     }
 
     fn exit_span(&mut self) -> io::Result<()> {
@@ -363,7 +363,7 @@ fn write_header(class: Option<&str>,
     if let Some(id) = id {
         write!(out, "id='{}' ", id)?;
     }
-    write!(out, "class='rust {}'>\n", class.unwrap_or(""))
+    write!(out, "class=\"rust {}\">\n", class.unwrap_or(""))
 }
 
 fn write_footer(out: &mut Write) -> io::Result<()> {
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
@@ -1547,7 +1547,7 @@ impl<'a> fmt::Display for Item<'a> {
                        component)?;
             }
         }
-        write!(fmt, "<a class='{}' href=''>{}</a>",
+        write!(fmt, "<a class=\"{}\" href=''>{}</a>",
                self.item.type_(), self.item.name.as_ref().unwrap())?;
 
         write!(fmt, "</span>")?; // in-band
@@ -1667,8 +1667,20 @@ fn md_render_assoc_item(item: &clean::Item) -> String {
     }
 }
 
+fn get_doc_value(item: &clean::Item) -> Option<&str> {
+    let x = item.doc_value();
+    if x.is_none() {
+        match item.inner {
+            clean::AssociatedConstItem(_, _) => Some(""),
+            _ => None,
+        }
+    } else {
+        x
+    }
+}
+
 fn document_full(w: &mut fmt::Formatter, item: &clean::Item) -> fmt::Result {
-    if let Some(s) = item.doc_value() {
+    if let Some(s) = get_doc_value(item) {
         write!(w, "<div class='docblock'>{}</div>",
                Markdown(&format!("{}{}", md_render_assoc_item(item), s)))?;
     }
@@ -1831,7 +1843,7 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
                 let doc_value = myitem.doc_value().unwrap_or("");
                 write!(w, "
                        <tr class='{stab} module-item'>
-                           <td><a class='{class}' href='{href}'
+                           <td><a class=\"{class}\" href=\"{href}\"
                                   title='{title_type} {title}'>{name}</a>{unsafety_flag}</td>
                            <td class='docblock-short'>
                                {stab_docs} {docs}
@@ -2228,20 +2240,21 @@ fn naive_assoc_href(it: &clean::Item, link: AssocItemLink) -> String {
 
 fn assoc_const(w: &mut fmt::Formatter,
                it: &clean::Item,
-               _ty: &clean::Type,
+               ty: &clean::Type,
                _default: Option<&String>,
                link: AssocItemLink) -> fmt::Result {
-    write!(w, "const <a href='{}' class='constant'><b>{}</b></a>",
+    write!(w, "const <a href='{}' class=\"constant\"><b>{}</b></a>: {}",
            naive_assoc_href(it, link),
-           it.name.as_ref().unwrap())?;
+           it.name.as_ref().unwrap(),
+           ty)?;
     Ok(())
 }
 
 fn assoc_type(w: &mut fmt::Formatter, it: &clean::Item,
               bounds: &Vec<clean::TyParamBound>,
               default: Option<&clean::Type>,
               link: AssocItemLink) -> fmt::Result {
-    write!(w, "type <a href='{}' class='type'>{}</a>",
+    write!(w, "type <a href='{}' class=\"type\">{}</a>",
            naive_assoc_href(it, link),
            it.name.as_ref().unwrap())?;
     if !bounds.is_empty() {
@@ -2384,7 +2397,7 @@ fn item_struct(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
                 let ns_id = derive_id(format!("{}.{}",
                                               field.name.as_ref().unwrap(),
                                               ItemType::StructField.name_space()));
-                write!(w, "<span id='{id}' class='{item_type}'>
+                write!(w, "<span id='{id}' class=\"{item_type}\">
                            <span id='{ns_id}' class='invisible'>
                            <code>{name}: {ty}</code>
                            </span></span>",
@@ -2426,7 +2439,7 @@ fn item_union(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
     if fields.peek().is_some() {
         write!(w, "<h2 class='fields'>Fields</h2>")?;
         for (field, ty) in fields {
-            write!(w, "<span id='{shortty}.{name}' class='{shortty}'><code>{name}: {ty}</code>
+            write!(w, "<span id='{shortty}.{name}' class=\"{shortty}\"><code>{name}: {ty}</code>
                        </span>",
                    shortty = ItemType::StructField,
                    name = field.name.as_ref().unwrap(),
@@ -2911,7 +2924,7 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
                 if render_method_item {
                     let id = derive_id(format!("{}.{}", item_type, name));
                     let ns_id = derive_id(format!("{}.{}", name, item_type.name_space()));
-                    write!(w, "<h4 id='{}' class='{}'>", id, item_type)?;
+                    write!(w, "<h4 id='{}' class=\"{}\">", id, item_type)?;
                     write!(w, "<span id='{}' class='invisible'>", ns_id)?;
                     write!(w, "<code>")?;
                     render_assoc_item(w, item, link.anchor(&id), ItemType::Impl)?;
@@ -2923,31 +2936,31 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
             clean::TypedefItem(ref tydef, _) => {
                 let id = derive_id(format!("{}.{}", ItemType::AssociatedType, name));
                 let ns_id = derive_id(format!("{}.{}", name, item_type.name_space()));
-                write!(w, "<h4 id='{}' class='{}'>", id, item_type)?;
+                write!(w, "<h4 id='{}' class=\"{}\">", id, item_type)?;
                 write!(w, "<span id='{}' class='invisible'><code>", ns_id)?;
                 assoc_type(w, item, &Vec::new(), Some(&tydef.type_), link.anchor(&id))?;
                 write!(w, "</code></span></h4>\n")?;
             }
             clean::AssociatedConstItem(ref ty, ref default) => {
                 let id = derive_id(format!("{}.{}", item_type, name));
                 let ns_id = derive_id(format!("{}.{}", name, item_type.name_space()));
-                write!(w, "<h4 id='{}' class='{}'>", id, item_type)?;
+                write!(w, "<h4 id='{}' class=\"{}\">", id, item_type)?;
                 write!(w, "<span id='{}' class='invisible'><code>", ns_id)?;
                 assoc_const(w, item, ty, default.as_ref(), link.anchor(&id))?;
                 write!(w, "</code></span></h4>\n")?;
             }
             clean::ConstantItem(ref c) => {
                 let id = derive_id(format!("{}.{}", item_type, name));
                 let ns_id = derive_id(format!("{}.{}", name, item_type.name_space()));
-                write!(w, "<h4 id='{}' class='{}'>", id, item_type)?;
+                write!(w, "<h4 id='{}' class=\"{}\">", id, item_type)?;
                 write!(w, "<span id='{}' class='invisible'><code>", ns_id)?;
                 assoc_const(w, item, &c.type_, Some(&c.expr), link.anchor(&id))?;
                 write!(w, "</code></span></h4>\n")?;
             }
             clean::AssociatedTypeItem(ref bounds, ref default) => {
                 let id = derive_id(format!("{}.{}", item_type, name));
                 let ns_id = derive_id(format!("{}.{}", name, item_type.name_space()));
-                write!(w, "<h4 id='{}' class='{}'>", id, item_type)?;
+                write!(w, "<h4 id='{}' class=\"{}\">", id, item_type)?;
                 write!(w, "<span id='{}' class='invisible'><code>", ns_id)?;
                 assoc_type(w, item, bounds, default.as_ref(), link.anchor(&id))?;
                 write!(w, "</code></span></h4>\n")?;
@@ -2965,7 +2978,7 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
                         // We need the stability of the item from the trait
                         // because impls can't have a stability.
                         document_stability(w, cx, it)?;
-                        if item.doc_value().is_some() {
+                        if get_doc_value(item).is_some() {
                             document_full(w, item)?;
                         } else {
                             // In case the item isn't documented,

Original file line number	Diff line number	Diff line change
`@@ -90,6 +90,16 @@ impl<'a, T: fmt::Display> fmt::Display for CommaSep<'a, T> {`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
	`93`	`+impl<'a, T: fmt::Debug> fmt::Debug for CommaSep<'a, T> {`
	`94`	`+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
	`95`	`+ for (i, item) in self.0.iter().enumerate() {`
	`96`	`+ if i != 0 { write!(f, ", ")?; }`
	`97`	`+ fmt::Debug::fmt(item, f)?;`
	`98`	`+ }`
	`99`	`+ Ok(())`
	`100`	`+ }`
	`101`	`+}`
	`102`	`+`
`93`	`103`	`impl<'a> fmt::Display for TyParamBounds<'a> {`
`94`	`104`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`95`	`105`	`let &TyParamBounds(bounds) = self;`
`@@ -165,7 +175,7 @@ impl<'a> fmt::Display for WhereClause<'a> {`
`165`	`175`	`if f.alternate() {`
`166`	`176`	`clause.push_str(" where ");`
`167`	`177`	`} else {`
`168`		`- clause.push_str(" <span class='where fmt-newline'>where ");`
	`178`	`+ clause.push_str(" <span class=\"where fmt-newline\">where ");`
`169`	`179`	`}`
`170`	`180`	`for (i, pred) in gens.where_predicates.iter().enumerate() {`
`171`	`181`	`if i > 0 {`
`@@ -449,8 +459,8 @@ fn resolved_path(w: &mut fmt::Formatter, did: DefId, path: &clean::Path,`
`449`	`459`	`} else {`
`450`	`460`	`root.push_str(&seg.name);`
`451`	`461`	`root.push_str("/");`
`452`		`- write!(w, "<a class='mod'`
`453`		`- href='{}index.html'>{}</a>::",`
	`462`	`+ write!(w, "<a class=\"mod\"`
	`463`	`+ href=\"{}index.html\">{}</a>::",`
`454`	`464`	`root,`
`455`	`465`	`seg.name)?;`
`456`	`466`	`}`
`@@ -491,7 +501,7 @@ fn primitive_link(f: &mut fmt::Formatter,`
`491`	`501`	`Some(&def_id) if def_id.is_local() => {`
`492`	`502`	`let len = CURRENT_LOCATION_KEY.with(\|s\| s.borrow().len());`
`493`	`503`	`let len = if len == 0 {0} else {len - 1};`
`494`		`- write!(f, "<a class='primitive' href='{}primitive.{}.html'>",`
	`504`	`+ write!(f, "<a class=\"primitive\" href=\"{}primitive.{}.html\">",`
`495`	`505`	`repeat("../").take(len).collect::<String>(),`
`496`	`506`	`prim.to_url_str())?;`
`497`	`507`	`needs_termination = true;`
`@@ -508,7 +518,7 @@ fn primitive_link(f: &mut fmt::Formatter,`
`508`	`518`	`(.., render::Unknown) => None,`
`509`	`519`	`};`
`510`	`520`	`if let Some((cname, root)) = loc {`
`511`		`- write!(f, "<a class='primitive' href='{}{}/primitive.{}.html'>",`
	`521`	`+ write!(f, "<a class=\"primitive\" href=\"{}{}/primitive.{}.html\">",`
`512`	`522`	`root,`
`513`	`523`	`cname,`
`514`	`524`	`prim.to_url_str())?;`
`@@ -550,7 +560,7 @@ impl<'a> fmt::Display for HRef<'a> {`
`550`	`560`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`551`	`561`	`match href(self.did) {`
`552`	`562`	`Some((url, shortty, fqp)) => if !f.alternate() {`
`553`		`- write!(f, "<a class='{}' href='{}' title='{} {}'>{}</a>",`
	`563`	`+ write!(f, "<a class=\"{}\" href=\"{}\" title=\"{} {}\">{}</a>",`
`554`	`564`	`shortty, url, shortty, fqp.join("::"), self.text)`
`555`	`565`	`} else {`
`556`	`566`	`write!(f, "{}", self.text)`
`@@ -599,21 +609,21 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,`
`599`	`609`	`fmt::Display::fmt(one, f)?;`
`600`	`610`	`primitive_link(f, PrimitiveType::Tuple, ",)")`
`601`	`611`	`}`
`602`		`- &[ref one] => write!(f, "({},)", one),`
	`612`	`+ &[ref one] => write!(f, "({:?},)", one),`
`603`	`613`	`many if is_not_debug => {`
`604`	`614`	`primitive_link(f, PrimitiveType::Tuple, "(")?;`
`605`	`615`	`fmt::Display::fmt(&CommaSep(&many), f)?;`
`606`	`616`	`primitive_link(f, PrimitiveType::Tuple, ")")`
`607`	`617`	`}`
`608`		`- many => write!(f, "({})", &CommaSep(&many)),`
	`618`	`+ many => write!(f, "({:?})", &CommaSep(&many)),`
`609`	`619`	`}`
`610`	`620`	`}`
`611`	`621`	`clean::Vector(ref t) if is_not_debug => {`
`612`	`622`	`primitive_link(f, PrimitiveType::Slice, &format!("["))?;`
`613`	`623`	`fmt::Display::fmt(t, f)?;`
`614`	`624`	`primitive_link(f, PrimitiveType::Slice, &format!("]"))`
`615`	`625`	`}`
`616`		`- clean::Vector(ref t) => write!(f, "[{}]", t),`
	`626`	`+ clean::Vector(ref t) => write!(f, "[{:?}]", t),`
`617`	`627`	`clean::FixedVector(ref t, ref s) if is_not_debug => {`
`618`	`628`	`primitive_link(f, PrimitiveType::Array, "[")?;`
`619`	`629`	`fmt::Display::fmt(t, f)?;`
`@@ -627,9 +637,9 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,`
`627`	`637`	`}`
`628`	`638`	`clean::FixedVector(ref t, ref s) => {`
`629`	`639`	`if f.alternate() {`
`630`		`- write!(f, "[{}; {}]", t, s)`
	`640`	`+ write!(f, "[{:?}; {}]", t, s)`
`631`	`641`	`} else {`
`632`		`- write!(f, "[{}; {}]", t, Escape(s))`
	`642`	`+ write!(f, "[{:?}; {}]", t, Escape(s))`
`633`	`643`	`}`
`634`	`644`	`}`
`635`	`645`	`clean::Never => f.write_str("!"),`
`@@ -646,9 +656,9 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,`
`646`	`656`	`}`
`647`	`657`	`clean::Generic(_) \| clean::ResolvedPath {is_generic: true, ..} => {`
`648`	`658`	`if f.alternate() {`
`649`		`- write!(f, "*{}{:#}", RawMutableSpace(m), t)`
	`659`	`+ write!(f, "*{}{:#?}", RawMutableSpace(m), t)`
`650`	`660`	`} else {`
`651`		`- write!(f, "*{}{}", RawMutableSpace(m), t)`
	`661`	`+ write!(f, "*{}{:?}", RawMutableSpace(m), t)`
`652`	`662`	`}`
`653`	`663`	`}`
`654`	`664`	`_ if is_not_debug => {`
`@@ -657,7 +667,7 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,`
`657`	`667`	`fmt::Display::fmt(t, f)`
`658`	`668`	`}`
`659`	`669`	`_ => {`
`660`		`- write!(f, "*{}{}", RawMutableSpace(m), t)`
	`670`	`+ write!(f, "*{}{:?}", RawMutableSpace(m), t)`
`661`	`671`	`}`
`662`	`672`	`}`
`663`	`673`	`}`
`@@ -681,9 +691,9 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,`
`681`	`691`	`}`
`682`	`692`	`clean::Generic(_) => {`
`683`	`693`	`if f.alternate() {`
`684`		`- write!(f, "&{}{}[{:#}]", lt, m, **bt)`
	`694`	`+ write!(f, "&{}{}[{:#?}]", lt, m, **bt)`
`685`	`695`	`} else {`
`686`		`- write!(f, "&{}{}[{}]", lt, m, **bt)`
	`696`	`+ write!(f, "&{}{}[{:?}]", lt, m, **bt)`
`687`	`697`	`}`
`688`	`698`	`}`
`689`	`699`	`_ if is_not_debug => {`
`@@ -700,9 +710,9 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,`
`700`	`710`	`}`
`701`	`711`	`_ => {`
`702`	`712`	`if f.alternate() {`
`703`		`- write!(f, "&{}{}[{:#}]", lt, m, **bt)`
	`713`	`+ write!(f, "&{}{}[{:#?}]", lt, m, **bt)`
`704`	`714`	`} else {`
`705`		`- write!(f, "&{}{}[{}]", lt, m, **bt)`
	`715`	`+ write!(f, "&{}{}[{:?}]", lt, m, **bt)`
`706`	`716`	`}`
`707`	`717`	`}`
`708`	`718`	`}`
`@@ -765,12 +775,16 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter, use_absolute: bool,`
`765`	`775`	`}`
`766`	`776`	`clean::QPath { ref name, ref self_type, ref trait_ } => {`
`767`	`777`	`if f.alternate() {`
`768`		`- write!(f, "<{:#} as {:#}>::{}", self_type, trait_, name)`
	`778`	`+ if is_not_debug {`
	`779`	`+ write!(f, "<{:#} as {:#}>::{}", self_type, trait_, name)`
	`780`	`+ } else {`
	`781`	`+ write!(f, "<{:#?} as {:#?}>::{}", self_type, trait_, name)`
	`782`	`+ }`
`769`	`783`	`} else {`
`770`	`784`	`if is_not_debug {`
`771`	`785`	`write!(f, "<{} as {}>::{}", self_type, trait_, name)`
`772`	`786`	`} else {`
`773`		`- write!(f, "<{} as {}>::{}", self_type, trait_, name)`
	`787`	`+ write!(f, "<{:?} as {:?}>::{}", self_type, trait_, name)`
`774`	`788`	`}`
`775`	`789`	`}`
`776`	`790`	`}`
Original file line number	Diff line number	Diff line change
`@@ -144,12 +144,12 @@ impl<U: Write> Writer for U {`
`144`	`144`	`-> io::Result<()> {`
`145`	`145`	`match klass {`
`146`	`146`	`Class::None => write!(self, "{}", text),`
`147`		`- klass => write!(self, "<span class='{}'>{}</span>", klass.rustdoc_class(), text),`
	`147`	`+ klass => write!(self, "<span class=\"{}\">{}</span>", klass.rustdoc_class(), text),`
`148`	`148`	`}`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`fn enter_span(&mut self, klass: Class) -> io::Result<()> {`
`152`		`- write!(self, "<span class='{}'>", klass.rustdoc_class())`
	`152`	`+ write!(self, "<span class=\"{}\">", klass.rustdoc_class())`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`fn exit_span(&mut self) -> io::Result<()> {`
`@@ -363,7 +363,7 @@ fn write_header(class: Option<&str>,`
`363`	`363`	`if let Some(id) = id {`
`364`	`364`	`write!(out, "id='{}' ", id)?;`
`365`	`365`	`}`
`366`		`- write!(out, "class='rust {}'>\n", class.unwrap_or(""))`
	`366`	`+ write!(out, "class=\"rust {}\">\n", class.unwrap_or(""))`
`367`	`367`	`}`
`368`	`368`
`369`	`369`	`fn write_footer(out: &mut Write) -> io::Result<()> {`