Show values for const values in the documentation

Author: ohadravid

src/librustdoc/clean/inline.rs

@@ -465,7 +465,8 @@ pub fn print_inlined_const(cx: &DocContext<'_>, did: DefId) -> String {
 fn build_const(cx: &DocContext<'_>, did: DefId) -> clean::Constant {
     clean::Constant {
         type_: cx.tcx.type_of(did).clean(cx),
-        expr: print_inlined_const(cx, did)
+        expr: print_inlined_const(cx, did),
+        value: clean::print_evaluated_const(cx, did),
     }
 }
 

src/librustdoc/clean/mod.rs

@@ -16,7 +16,7 @@ use rustc::infer::region_constraints::{RegionConstraintData, Constraint};
 use rustc::middle::resolve_lifetime as rl;
 use rustc::middle::lang_items;
 use rustc::middle::stability;
-use rustc::mir::interpret::GlobalId;
+use rustc::mir::interpret::{GlobalId, ConstValue, Scalar, sign_extend};
 use rustc::hir;
 use rustc::hir::def::{CtorKind, DefKind, Res};
 use rustc::hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
@@ -1300,6 +1300,7 @@ impl Clean<Constant> for hir::ConstArg {
         Constant {
             type_: cx.tcx.type_of(cx.tcx.hir().body_owner_def_id(self.value.body)).clean(cx),
             expr: print_const_expr(cx, self.value.body),
+            value: None,
         }
     }
 }
@@ -3274,6 +3275,7 @@ impl<'tcx> Clean<Constant> for ty::Const<'tcx> {
         Constant {
             type_: self.ty.clean(cx),
             expr: format!("{}", self),
+            value: None,
         }
     }
 }
@@ -3831,21 +3833,24 @@ impl Clean<Item> for doctree::Static<'_> {
 pub struct Constant {
     pub type_: Type,
     pub expr: String,
+    pub value: Option<String>,
 }
 
 impl Clean<Item> for doctree::Constant<'_> {
     fn clean(&self, cx: &DocContext<'_>) -> Item {
+        let def_id = cx.tcx.hir().local_def_id(self.id);
         Item {
             name: Some(self.name.clean(cx)),
             attrs: self.attrs.clean(cx),
             source: self.whence.clean(cx),
-            def_id: cx.tcx.hir().local_def_id(self.id),
+            def_id: def_id,
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id).clean(cx),
             deprecation: cx.deprecation(self.id).clean(cx),
             inner: ConstantItem(Constant {
                 type_: self.type_.clean(cx),
                 expr: print_const_expr(cx, self.expr),
+                value: print_evaluated_const(cx, def_id),
             }),
         }
     }
@@ -4232,6 +4237,50 @@ fn name_from_pat(p: &hir::Pat) -> String {
     }
 }
 
+pub fn print_evaluated_const(cx: &DocContext<'_>, def_id: DefId) -> Option<String> {
+    let param_env = cx.tcx.param_env(def_id);
+    let substs = InternalSubsts::identity_for_item(cx.tcx, def_id);
+    let cid = GlobalId {
+        instance: ty::Instance::new(def_id, substs),
+        promoted: None
+    };
+
+    let value = cx.tcx.const_eval(param_env.and(cid)).ok().and_then(|value| {
+        match (value.val, &value.ty.kind) {
+            (_, ty::Ref(..)) => None,
+            (ty::ConstKind::Value(ConstValue::Scalar(_)), _) =>
+                Some(print_const_with_custom_print_scalar(cx, value)),
+            _ => None,
+        }
+    });
+
+    value
+}
+
+fn print_const_with_custom_print_scalar(cx: &DocContext<'_>, ct: &'tcx ty::Const<'tcx>) -> String {
+    // Use a slightly different format for integer types which always shows the actual value.
+    // For all other types, fallback to the original `pretty_print_const`.
+    match (ct.val, &ct.ty.kind) {
+        (ty::ConstKind::Value(ConstValue::Scalar(Scalar::Raw { data, .. })), ty::Uint(ui)) => {
+            let ui_str = ui.name_str();
+            format!("{}{}", data, ui_str)
+        },
+        (ty::ConstKind::Value(ConstValue::Scalar(Scalar::Raw { data, .. })), ty::Int(i)) => {
+            let ty = cx.tcx.lift(&ct.ty).unwrap();
+            let size = cx.tcx.layout_of(ty::ParamEnv::empty().and(ty))
+                .unwrap()
+                .size;
+            let i_str = i.name_str();
+            let sign_extended_data = sign_extend(data, size) as i128;
+
+            format!("{}{}", sign_extended_data, i_str)
+        },
+        _ => {
+            ct.to_string()
+        }
+    }
+}
+
 fn print_const(cx: &DocContext<'_>, n: &ty::Const<'_>) -> String {
     match n.val {
         ty::ConstKind::Unevaluated(def_id, _) => {

src/librustdoc/html/render.rs

@@ -2287,11 +2287,22 @@ fn short_stability(item: &clean::Item, cx: &Context) -> Vec<String> {
 fn item_constant(w: &mut Buffer, cx: &Context, it: &clean::Item, c: &clean::Constant) {
     write!(w, "<pre class='rust const'>");
     render_attributes(w, it, false);
+
     write!(w, "{vis}const \
-               {name}: {typ}</pre>",
+               {name}: {typ} = {expr};",
            vis = it.visibility.print_with_space(),
            name = it.name.as_ref().unwrap(),
-           typ = c.type_.print());
+           typ = c.type_.print(),
+           expr = c.expr,
+    );
+
+    if let Some(value) = &c.value {
+        if value != &c.expr {
+            write!(w, " /* {value} */", value = value);
+        }
+    }
+
+    write!(w, "</pre>");
     document(w, cx, it)
 }
 

src/test/rustdoc/dont-show-const-contents.rs

@@ -0,0 +1,29 @@
+// Test that the contents of constants are displayed as part of the
+// documentation.
+
+// @has show_const_contents/constant.CONST_S.html 'show this'
+pub const CONST_S: &'static str = "show this";
+
+// @has show_const_contents/constant.CONST_I32.html '= 42; /* 42i32 */'
+pub const CONST_I32: i32 = 42;
+
+// @has show_const_contents/constant.CONST_EQ_TO_VALUE_I32.html '= 42i32;'
+// @!has show_const_contents/constant.CONST_EQ_TO_VALUE_I32.html '/* 42i32 */'
+pub const CONST_EQ_TO_VALUE_I32: i32 = 42i32;
+
+// @has show_const_contents/constant.CONST_CALC_I32.html '= 42 + 1; /* 43i32 */'
+pub const CONST_CALC_I32: i32 = 42 + 1;
+
+// @has show_const_contents/constant.CONST_REF_I32.html '= &42;'
+pub const CONST_REF_I32: &'static i32 = &42;
+
+// @has show_const_contents/constant.CONST_I32_MAX.html '= i32::max_value(); /* 2147483647i32 */'
+pub const CONST_I32_MAX: i32 = i32::max_value();
+
+// @has show_const_contents/constant.UNIT.html '= ();'
+pub const UNIT: () = ();
+
+pub struct MyType(i32);
+
+// @has show_const_contents/constant.MY_TYPE.html '= MyType(42);'
+pub const MY_TYPE: MyType = MyType(42);