Add Const kind to rustdoc

varkor · yodaldevoid · varkor · commit 475f20c73db5 · 2019-02-15T22:28:49.000Z
Co-Authored-By: Gabriel Smith &lt;yodaldevoid@users.noreply.github.com&gt;
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
@@ -773,6 +773,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
                     }
                 }
                 GenericParamDefKind::Lifetime => {}
+                GenericParamDefKind::Const { .. } => {}
             }
         }
 
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -1253,6 +1253,15 @@ impl Clean<Lifetime> for hir::GenericParam {
     }
 }
 
+impl Clean<Constant> for hir::ConstArg {
+    fn clean(&self, cx: &DocContext) -> Constant {
+        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),
+        }
+    }
+}
+
 impl<'tcx> Clean<Lifetime> for ty::GenericParamDef {
     fn clean(&self, _cx: &DocContext) -> Lifetime {
         Lifetime(self.name.to_string())
@@ -1418,6 +1427,10 @@ pub enum GenericParamDefKind {
         default: Option<Type>,
         synthetic: Option<hir::SyntheticTyParamKind>,
     },
+    Const {
+        did: DefId,
+        ty: Type,
+    },
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)]
@@ -1430,7 +1443,10 @@ pub struct GenericParamDef {
 impl GenericParamDef {
     pub fn is_synthetic_type_param(&self) -> bool {
         match self.kind {
-            GenericParamDefKind::Lifetime => false,
+            GenericParamDefKind::Lifetime |
+            GenericParamDefKind::Const { .. } => {
+                false
+            }
             GenericParamDefKind::Type { ref synthetic, .. } => synthetic.is_some(),
         }
     }
@@ -1494,6 +1510,12 @@ impl Clean<GenericParamDef> for hir::GenericParam {
                     synthetic: synthetic,
                 })
             }
+            hir::GenericParamKind::Const { ref ty } => {
+                (self.name.ident().name.clean(cx), GenericParamDefKind::Const {
+                    did: cx.tcx.hir().local_def_id(self.id),
+                    ty: ty.clean(cx),
+                })
+            }
         };
 
         GenericParamDef {
@@ -1533,6 +1555,7 @@ impl Clean<Generics> for hir::Generics {
                     GenericParamDefKind::Type { did, ref bounds, .. } => {
                         cx.impl_trait_bounds.borrow_mut().insert(did, bounds.clone());
                     }
+                    GenericParamDefKind::Const { .. } => unreachable!(),
                 }
                 param
             })
@@ -1566,6 +1589,7 @@ impl Clean<Generics> for hir::Generics {
                                         break
                                     }
                                 }
+                                GenericParamDefKind::Const { .. } => {}
                             }
                         }
                     }
@@ -2544,6 +2568,7 @@ impl Clean<Type> for hir::Ty {
                     let provided_params = &path.segments.last().expect("segments were empty");
                     let mut ty_substs = FxHashMap::default();
                     let mut lt_substs = FxHashMap::default();
+                    let mut const_substs = FxHashMap::default();
                     provided_params.with_generic_args(|generic_args| {
                         let mut indices: GenericParamCount = Default::default();
                         for param in generics.params.iter() {
@@ -2595,10 +2620,32 @@ impl Clean<Type> for hir::Ty {
                                     }
                                     indices.types += 1;
                                 }
+                                hir::GenericParamKind::Const { .. } => {
+                                    let const_param_def =
+                                        Def::ConstParam(cx.tcx.hir().local_def_id(param.id));
+                                    let mut j = 0;
+                                    let const_ = generic_args.args.iter().find_map(|arg| {
+                                        match arg {
+                                            hir::GenericArg::Const(ct) => {
+                                                if indices.consts == j {
+                                                    return Some(ct);
+                                                }
+                                                j += 1;
+                                                None
+                                            }
+                                            _ => None,
+                                        }
+                                    });
+                                    if let Some(ct) = const_.cloned() {
+                                        const_substs.insert(const_param_def, ct.clean(cx));
+                                    }
+                                    // FIXME(const_generics:defaults)
+                                    indices.consts += 1;
+                                }
                             }
                         }
                     });
-                    return cx.enter_alias(ty_substs, lt_substs, || ty.clean(cx));
+                    return cx.enter_alias(ty_substs, lt_substs, const_substs, || ty.clean(cx));
                 }
                 resolve_type(cx, path.clean(cx), self.id)
             }
@@ -3190,6 +3237,9 @@ impl Clean<GenericArgs> for hir::GenericArgs {
                     GenericArg::Type(ty) => {
                         types.push(ty.clean(cx));
                     }
+                    GenericArg::Const(..) => {
+                        unimplemented!() // FIXME(const_generics)
+                    }
                 }
             }
             GenericArgs::AngleBracketed {
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
@@ -65,6 +65,8 @@ pub struct DocContext<'a, 'tcx: 'a, 'rcx: 'a> {
     pub ty_substs: RefCell<FxHashMap<Def, clean::Type>>,
     /// Table `NodeId` of lifetime parameter definition -> substituted lifetime
     pub lt_substs: RefCell<FxHashMap<DefId, clean::Lifetime>>,
+    /// Table node id of const parameter definition -> substituted const
+    pub ct_substs: RefCell<FxHashMap<Def, clean::Constant>>,
     /// Table DefId of `impl Trait` in argument position -> bounds
     pub impl_trait_bounds: RefCell<FxHashMap<DefId, Vec<clean::GenericBound>>>,
     pub send_trait: Option<DefId>,
@@ -85,14 +87,18 @@ impl<'a, 'tcx, 'rcx> DocContext<'a, 'tcx, 'rcx> {
     pub fn enter_alias<F, R>(&self,
                              ty_substs: FxHashMap<Def, clean::Type>,
                              lt_substs: FxHashMap<DefId, clean::Lifetime>,
+                             ct_substs: FxHashMap<Def, clean::Constant>,
                              f: F) -> R
     where F: FnOnce() -> R {
-        let (old_tys, old_lts) =
-            (mem::replace(&mut *self.ty_substs.borrow_mut(), ty_substs),
-             mem::replace(&mut *self.lt_substs.borrow_mut(), lt_substs));
+        let (old_tys, old_lts, old_cts) = (
+            mem::replace(&mut *self.ty_substs.borrow_mut(), ty_substs),
+            mem::replace(&mut *self.lt_substs.borrow_mut(), lt_substs),
+            mem::replace(&mut *self.ct_substs.borrow_mut(), ct_substs),
+        );
         let r = f();
         *self.ty_substs.borrow_mut() = old_tys;
         *self.lt_substs.borrow_mut() = old_lts;
+        *self.ct_substs.borrow_mut() = old_cts;
         r
     }
 
@@ -527,6 +533,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
                 renderinfo: RefCell::new(renderinfo),
                 ty_substs: Default::default(),
                 lt_substs: Default::default(),
+                ct_substs: Default::default(),
                 impl_trait_bounds: Default::default(),
                 send_trait: send_trait,
                 fake_def_ids: Default::default(),
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
@@ -138,6 +138,16 @@ impl fmt::Display for clean::GenericParamDef {
 
                 Ok(())
             }
+            clean::GenericParamDefKind::Const { ref ty, .. } => {
+                f.write_str("const ")?;
+                f.write_str(&self.name)?;
+
+                if f.alternate() {
+                    write!(f, ": {:#}", ty)
+                } else {
+                    write!(f, ":&nbsp;{}", ty)
+                }
+            }
         }
     }
 }
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
@@ -1746,7 +1746,8 @@ impl<'a> Cache {
         for param in &generics.params {
             match param.kind {
                 clean::GenericParamDefKind::Lifetime => {}
-                clean::GenericParamDefKind::Type { did, .. } => {
+                clean::GenericParamDefKind::Type { did, .. } |
+                clean::GenericParamDefKind::Const { did, .. } => {
                     self.typarams.insert(did, param.name.clone());
                 }
             }

Original file line number	Diff line number	Diff line change
`@@ -773,6 +773,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {`
`773`	`773`	`}`
`774`	`774`	`}`
`775`	`775`	`GenericParamDefKind::Lifetime => {}`
	`776`	`+ GenericParamDefKind::Const { .. } => {}`
`776`	`777`	`}`
`777`	`778`	`}`
`778`	`779`
Original file line number	Diff line number	Diff line change
`@@ -1253,6 +1253,15 @@ impl Clean<Lifetime> for hir::GenericParam {`
`1253`	`1253`	`}`
`1254`	`1254`	`}`
`1255`	`1255`
	`1256`	`+impl Clean<Constant> for hir::ConstArg {`
	`1257`	`+ fn clean(&self, cx: &DocContext) -> Constant {`
	`1258`	`+ Constant {`
	`1259`	`+ type_: cx.tcx.type_of(cx.tcx.hir().body_owner_def_id(self.value.body)).clean(cx),`
	`1260`	`+ expr: print_const_expr(cx, self.value.body),`
	`1261`	`+ }`
	`1262`	`+ }`
	`1263`	`+}`
	`1264`	`+`
`1256`	`1265`	`impl<'tcx> Clean<Lifetime> for ty::GenericParamDef {`
`1257`	`1266`	`fn clean(&self, _cx: &DocContext) -> Lifetime {`
`1258`	`1267`	`Lifetime(self.name.to_string())`
`@@ -1418,6 +1427,10 @@ pub enum GenericParamDefKind {`
`1418`	`1427`	`default: Option<Type>,`
`1419`	`1428`	`synthetic: Option<hir::SyntheticTyParamKind>,`
`1420`	`1429`	`},`
	`1430`	`+ Const {`
	`1431`	`+ did: DefId,`
	`1432`	`+ ty: Type,`
	`1433`	`+ },`
`1421`	`1434`	`}`
`1422`	`1435`
`1423`	`1436`	`#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Debug, Hash)]`
`@@ -1430,7 +1443,10 @@ pub struct GenericParamDef {`
`1430`	`1443`	`impl GenericParamDef {`
`1431`	`1444`	`pub fn is_synthetic_type_param(&self) -> bool {`
`1432`	`1445`	`match self.kind {`
`1433`		`- GenericParamDefKind::Lifetime => false,`
	`1446`	`+ GenericParamDefKind::Lifetime \|`
	`1447`	`+ GenericParamDefKind::Const { .. } => {`
	`1448`	`+ false`
	`1449`	`+ }`
`1434`	`1450`	`GenericParamDefKind::Type { ref synthetic, .. } => synthetic.is_some(),`
`1435`	`1451`	`}`
`1436`	`1452`	`}`
`@@ -1494,6 +1510,12 @@ impl Clean<GenericParamDef> for hir::GenericParam {`
`1494`	`1510`	`synthetic: synthetic,`
`1495`	`1511`	`})`
`1496`	`1512`	`}`
	`1513`	`+ hir::GenericParamKind::Const { ref ty } => {`
	`1514`	`+ (self.name.ident().name.clean(cx), GenericParamDefKind::Const {`
	`1515`	`+ did: cx.tcx.hir().local_def_id(self.id),`
	`1516`	`+ ty: ty.clean(cx),`
	`1517`	`+ })`
	`1518`	`+ }`
`1497`	`1519`	`};`
`1498`	`1520`
`1499`	`1521`	`GenericParamDef {`
`@@ -1533,6 +1555,7 @@ impl Clean<Generics> for hir::Generics {`
`1533`	`1555`	`GenericParamDefKind::Type { did, ref bounds, .. } => {`
`1534`	`1556`	`cx.impl_trait_bounds.borrow_mut().insert(did, bounds.clone());`
`1535`	`1557`	`}`
	`1558`	`+ GenericParamDefKind::Const { .. } => unreachable!(),`
`1536`	`1559`	`}`
`1537`	`1560`	`param`
`1538`	`1561`	`})`
`@@ -1566,6 +1589,7 @@ impl Clean<Generics> for hir::Generics {`
`1566`	`1589`	`break`
`1567`	`1590`	`}`
`1568`	`1591`	`}`
	`1592`	`+ GenericParamDefKind::Const { .. } => {}`
`1569`	`1593`	`}`
`1570`	`1594`	`}`
`1571`	`1595`	`}`
`@@ -2544,6 +2568,7 @@ impl Clean<Type> for hir::Ty {`
`2544`	`2568`	`let provided_params = &path.segments.last().expect("segments were empty");`
`2545`	`2569`	`let mut ty_substs = FxHashMap::default();`
`2546`	`2570`	`let mut lt_substs = FxHashMap::default();`
	`2571`	`+ let mut const_substs = FxHashMap::default();`
`2547`	`2572`	`provided_params.with_generic_args(\|generic_args\| {`
`2548`	`2573`	`let mut indices: GenericParamCount = Default::default();`
`2549`	`2574`	`for param in generics.params.iter() {`
`@@ -2595,10 +2620,32 @@ impl Clean<Type> for hir::Ty {`
`2595`	`2620`	`}`
`2596`	`2621`	`indices.types += 1;`
`2597`	`2622`	`}`
	`2623`	`+ hir::GenericParamKind::Const { .. } => {`
	`2624`	`+ let const_param_def =`
	`2625`	`+ Def::ConstParam(cx.tcx.hir().local_def_id(param.id));`
	`2626`	`+ let mut j = 0;`
	`2627`	`+ let const_ = generic_args.args.iter().find_map(\|arg\| {`
	`2628`	`+ match arg {`
	`2629`	`+ hir::GenericArg::Const(ct) => {`
	`2630`	`+ if indices.consts == j {`
	`2631`	`+ return Some(ct);`
	`2632`	`+ }`
	`2633`	`+ j += 1;`
	`2634`	`+ None`
	`2635`	`+ }`
	`2636`	`+ _ => None,`
	`2637`	`+ }`
	`2638`	`+ });`
	`2639`	`+ if let Some(ct) = const_.cloned() {`
	`2640`	`+ const_substs.insert(const_param_def, ct.clean(cx));`
	`2641`	`+ }`
	`2642`	`+ // FIXME(const_generics:defaults)`
	`2643`	`+ indices.consts += 1;`
	`2644`	`+ }`
`2598`	`2645`	`}`
`2599`	`2646`	`}`
`2600`	`2647`	`});`
`2601`		`- return cx.enter_alias(ty_substs, lt_substs, \|\| ty.clean(cx));`
	`2648`	`+ return cx.enter_alias(ty_substs, lt_substs, const_substs, \|\| ty.clean(cx));`
`2602`	`2649`	`}`
`2603`	`2650`	`resolve_type(cx, path.clean(cx), self.id)`
`2604`	`2651`	`}`
`@@ -3190,6 +3237,9 @@ impl Clean<GenericArgs> for hir::GenericArgs {`
`3190`	`3237`	`GenericArg::Type(ty) => {`
`3191`	`3238`	`types.push(ty.clean(cx));`
`3192`	`3239`	`}`
	`3240`	`+ GenericArg::Const(..) => {`
	`3241`	`+ unimplemented!() // FIXME(const_generics)`
	`3242`	`+ }`
`3193`	`3243`	`}`
`3194`	`3244`	`}`
`3195`	`3245`	`GenericArgs::AngleBracketed {`
Original file line number	Diff line number	Diff line change
`@@ -138,6 +138,16 @@ impl fmt::Display for clean::GenericParamDef {`
`138`	`138`
`139`	`139`	`Ok(())`
`140`	`140`	`}`
	`141`	`+ clean::GenericParamDefKind::Const { ref ty, .. } => {`
	`142`	`+ f.write_str("const ")?;`
	`143`	`+ f.write_str(&self.name)?;`
	`144`	`+`
	`145`	`+ if f.alternate() {`
	`146`	`+ write!(f, ": {:#}", ty)`
	`147`	`+ } else {`
	`148`	`+ write!(f, ": {}", ty)`
	`149`	`+ }`
	`150`	`+ }`
`141`	`151`	`}`
`142`	`152`	`}`
`143`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1746,7 +1746,8 @@ impl<'a> Cache {`
`1746`	`1746`	`for param in &generics.params {`
`1747`	`1747`	`match param.kind {`
`1748`	`1748`	`clean::GenericParamDefKind::Lifetime => {}`
`1749`		`- clean::GenericParamDefKind::Type { did, .. } => {`
	`1749`	`+ clean::GenericParamDefKind::Type { did, .. } \|`
	`1750`	`+ clean::GenericParamDefKind::Const { did, .. } => {`
`1750`	`1751`	`self.typarams.insert(did, param.name.clone());`
`1751`	`1752`	`}`
`1752`	`1753`	`}`