Check for const_unstable before printing const

src/librustdoc/html/format.rs

@@ -9,6 +9,7 @@ use std::cell::Cell;
 use std::fmt;
 use std::iter;
 
+use rustc_attr::{ConstStability, StabilityLevel};
 use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
@@ -1253,15 +1254,6 @@ impl PrintWithSpace for hir::Unsafety {
     }
 }
 
-impl PrintWithSpace for hir::Constness {
-    fn print_with_space(&self) -> &str {
-        match self {
-            hir::Constness::Const => "const ",
-            hir::Constness::NotConst => "",
-        }
-    }
-}
-
 impl PrintWithSpace for hir::IsAsync {
     fn print_with_space(&self) -> &str {
         match self {
@@ -1280,6 +1272,22 @@ impl PrintWithSpace for hir::Mutability {
     }
 }
 
+crate fn print_constness_with_space(
+    c: &hir::Constness,
+    s: Option<&ConstStability>,
+) -> &'static str {
+    match (c, s) {
+        // const stable or no stability attribute
+        (
+            hir::Constness::Const,
+            Some(ConstStability { level: StabilityLevel::Stable { .. }, .. }),
+        )
+        | (hir::Constness::Const, None) => "const ",
+        // const unstable or not const
+        (hir::Constness::Const, _) | (hir::Constness::NotConst, _) => "",
+    }
+}
+
 impl clean::Import {
     crate fn print<'a, 'tcx: 'a>(
         &'a self,

src/librustdoc/html/render/mod.rs

@@ -61,8 +61,8 @@ use crate::formats::item_type::ItemType;
 use crate::formats::{AssocItemRender, Impl, RenderMode};
 use crate::html::escape::Escape;
 use crate::html::format::{
-    href, print_abi_with_space, print_default_space, print_generic_bounds, print_where_clause,
+    href, print_abi_with_space, print_constness_with_space, print_default_space,
-    Buffer, PrintWithSpace,
+    print_generic_bounds, print_where_clause, Buffer, PrintWithSpace,
 };
 use crate::html::markdown::{Markdown, MarkdownHtml, MarkdownSummaryLine};
 
@@ -833,16 +833,17 @@ fn render_stability_since_raw(
     let ver = ver.filter(|inner| !inner.is_empty());
 
     match (ver, const_stability) {
+        // stable and const stable
         (Some(v), Some(ConstStability { level: StabilityLevel::Stable { since }, .. }))
             if Some(since.as_str()).as_deref() != containing_const_ver =>
         {
             write!(
                 w,
                 "<span class=\"since\" title=\"Stable since Rust version {0}, const since {1}\">{0} (const: {1})</span>",
-                v,
+                v, since
-                since.as_str()
             );
         }
+        // stable and const unstable
         (
             Some(v),
             Some(ConstStability { level: StabilityLevel::Unstable { issue, .. }, feature, .. }),
@@ -863,6 +864,7 @@ fn render_stability_since_raw(
             }
             write!(w, ")</span>");
         }
+        // stable
         (Some(v), _) if ver != containing_ver => {
             write!(
                 w,
@@ -910,11 +912,13 @@ fn render_assoc_item(
             }
         };
         let vis = meth.visibility.print_with_space(meth.def_id, cx).to_string();
-        let constness = header.constness.print_with_space();
+        let constness =
+            print_constness_with_space(&header.constness, meth.const_stability(cx.tcx()));
         let asyncness = header.asyncness.print_with_space();
         let unsafety = header.unsafety.print_with_space();
         let defaultness = print_default_space(meth.is_default());
         let abi = print_abi_with_space(header.abi).to_string();
+
         // NOTE: `{:#}` does not print HTML formatting, `{}` does. So `g.print` can't be reused between the length calculation and `write!`.
         let generics_len = format!("{:#}", g.print(cx)).len();
         let mut header_len = "fn ".len()
@@ -939,15 +943,15 @@ fn render_assoc_item(
         w.reserve(header_len + "<a href=\"\" class=\"fnname\">{".len() + "</a>".len());
         write!(
             w,
-            "{}{}{}{}{}{}{}fn <a href=\"{href}\" class=\"fnname\">{name}</a>\
+            "{indent}{vis}{constness}{asyncness}{unsafety}{defaultness}{abi}fn <a href=\"{href}\" class=\"fnname\">{name}</a>\
              {generics}{decl}{notable_traits}{where_clause}",
-            indent_str,
+            indent = indent_str,
-            vis,
+            vis = vis,
-            constness,
+            constness = constness,
-            asyncness,
+            asyncness = asyncness,
-            unsafety,
+            unsafety = unsafety,
-            defaultness,
+            defaultness = defaultness,
-            abi,
+            abi = abi,
             href = href,
             name = name,
             generics = g.print(cx),

src/librustdoc/html/render/print_item.rs

@@ -22,7 +22,9 @@ use crate::clean::{self, GetDefId};
 use crate::formats::item_type::ItemType;
 use crate::formats::{AssocItemRender, Impl, RenderMode};
 use crate::html::escape::Escape;
-use crate::html::format::{print_abi_with_space, print_where_clause, Buffer, PrintWithSpace};
+use crate::html::format::{
+    print_abi_with_space, print_constness_with_space, print_where_clause, Buffer, PrintWithSpace,
+};
 use crate::html::highlight;
 use crate::html::layout::Page;
 use crate::html::markdown::MarkdownSummaryLine;
@@ -430,29 +432,36 @@ fn extra_info_tags(item: &clean::Item, parent: &clean::Item, tcx: TyCtxt<'_>) ->
 }
 
 fn item_function(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, f: &clean::Function) {
-    let header_len = format!(
+    let vis = it.visibility.print_with_space(it.def_id, cx).to_string();
-        "{}{}{}{}{:#}fn {}{:#}",
+    let constness = print_constness_with_space(&f.header.constness, it.const_stability(cx.tcx()));
-        it.visibility.print_with_space(it.def_id, cx),
+    let asyncness = f.header.asyncness.print_with_space();
-        f.header.constness.print_with_space(),
+    let unsafety = f.header.unsafety.print_with_space();
-        f.header.asyncness.print_with_space(),
+    let abi = print_abi_with_space(f.header.abi).to_string();
-        f.header.unsafety.print_with_space(),
+    let name = it.name.as_ref().unwrap();
-        print_abi_with_space(f.header.abi),
+
-        it.name.as_ref().unwrap(),
+    let generics_len = format!("{:#}", f.generics.print(cx)).len();
-        f.generics.print(cx),
+    let header_len = "fn ".len()
-    )
+        + vis.len()
-    .len();
+        + constness.len()
+        + asyncness.len()
+        + unsafety.len()
+        + abi.len()
+        + name.as_str().len()
+        + generics_len;
+
     w.write_str("<pre class=\"rust fn\">");
     render_attributes_in_pre(w, it, "");
+    w.reserve(header_len);
     write!(
         w,
         "{vis}{constness}{asyncness}{unsafety}{abi}fn \
          {name}{generics}{decl}{notable_traits}{where_clause}</pre>",
-        vis = it.visibility.print_with_space(it.def_id, cx),
+        vis = vis,
-        constness = f.header.constness.print_with_space(),
+        constness = constness,
-        asyncness = f.header.asyncness.print_with_space(),
+        asyncness = asyncness,
-        unsafety = f.header.unsafety.print_with_space(),
+        unsafety = unsafety,
-        abi = print_abi_with_space(f.header.abi),
+        abi = abi,
-        name = it.name.as_ref().unwrap(),
+        name = name,
         generics = f.generics.print(cx),
         where_clause = print_where_clause(&f.generics, cx, 0, true),
         decl = f.decl.full_print(header_len, 0, f.header.asyncness, cx),

src/test/rustdoc/const-display.rs

@@ -7,11 +7,11 @@
 #![feature(foo, foo2)]
 #![feature(staged_api)]
 
-// @has 'foo/fn.foo.html' '//pre' 'pub unsafe fn foo() -> u32'
+// @has 'foo/fn.foo.html' '//pre' 'pub fn foo() -> u32'
 // @has - '//span[@class="since"]' '1.0.0 (const: unstable)'
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_unstable(feature="foo", issue = "none")]
-pub const unsafe fn foo() -> u32 { 42 }
+pub const fn foo() -> u32 { 42 }
 
 // @has 'foo/fn.foo2.html' '//pre' 'pub const fn foo2() -> u32'
 #[unstable(feature = "humans", issue = "none")]
@@ -39,11 +39,11 @@ pub const unsafe fn bar_not_gated() -> u32 { 42 }
 pub struct Foo;
 
 impl Foo {
-    // @has 'foo/struct.Foo.html' '//div[@id="method.gated"]/code' 'pub unsafe fn gated() -> u32'
+    // @has 'foo/struct.Foo.html' '//div[@id="method.gated"]/code' 'pub fn gated() -> u32'
     // @has - '//span[@class="since"]' '1.0.0 (const: unstable)'
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_const_unstable(feature="foo", issue = "none")]
-    pub const unsafe fn gated() -> u32 { 42 }
+    pub const fn gated() -> u32 { 42 }
 
     // @has 'foo/struct.Foo.html' '//div[@id="method.stable_impl"]/code' 'pub const fn stable_impl() -> u32'
     // @has - '//span[@class="since"]' '1.0.0 (const: 1.2.0)'