Improve new Constant variants' name

src/librustdoc/clean/inline.rs

@@ -500,7 +500,7 @@ crate fn print_inlined_const(tcx: TyCtxt<'_>, did: DefId) -> String {
 }
 
 fn build_const(cx: &mut DocContext<'_>, did: DefId) -> clean::Constant {
-    clean::Constant::Inline { type_: cx.tcx.type_of(did).clean(cx), did }
+    clean::Constant::Extern { type_: cx.tcx.type_of(did).clean(cx), did }
 }
 
 fn build_static(cx: &mut DocContext<'_>, did: DefId, mutable: bool) -> clean::Static {

src/librustdoc/clean/mod.rs

@@ -393,7 +393,7 @@ impl Clean<Lifetime> for hir::GenericParam<'_> {
 
 impl Clean<Constant> for hir::ConstArg {
     fn clean(&self, cx: &mut DocContext<'_>) -> Constant {
-        Constant::Generic {
+        Constant::Anonymous {
             type_: cx
                 .tcx
                 .type_of(cx.tcx.hir().body_owner_def_id(self.value.body).to_def_id())
@@ -1945,7 +1945,7 @@ impl Clean<Vec<Item>> for (&hir::Item<'_>, Option<Symbol>) {
                 ItemKind::Static(ty, mutability, body_id) => {
                     StaticItem(Static { type_: ty.clean(cx), mutability, expr: Some(body_id) })
                 }
-                ItemKind::Const(ty, body_id) => ConstantItem(Constant::Const {
+                ItemKind::Const(ty, body_id) => ConstantItem(Constant::Local {
                     type_: ty.clean(cx),
                     body: body_id,
                     did: def_id,

src/librustdoc/clean/types.rs

@@ -1988,41 +1988,42 @@ crate struct Static {
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
 crate enum Constant {
-    /// Typed constant value.
+    /// This is the wrapper around `ty::Const` for a non-local constant. Because it doesn't have a
+    /// `BodyId`, we need to handle it on its own.
     TyConst { type_: Type, expr: String },
     /// A constant (expression) that’s not an item or associated item. These are usually found
     /// nested inside types (e.g., array lengths) or expressions (e.g., repeat counts), and also
     /// used to define explicit discriminant values for enum variants.
-    Generic { type_: Type, body: BodyId },
-    /// Inlined constant (from another crate).
-    Inline { type_: Type, did: DefId },
+    Anonymous { type_: Type, body: BodyId },
+    /// Inlined constant.
+    Extern { type_: Type, did: DefId },
     /// const FOO: u32 = ...;
-    Const { type_: Type, did: DefId, body: BodyId },
+    Local { type_: Type, did: DefId, body: BodyId },
 }
 
 impl Constant {
     crate fn expr(&self, tcx: TyCtxt<'_>) -> String {
         match self {
             Self::TyConst { expr, .. } => expr.clone(),
-            Self::Inline { did, .. } => print_inlined_const(tcx, *did),
-            Self::Const { body, .. } | Self::Generic { body, .. } => print_const_expr(tcx, *body),
+            Self::Extern { did, .. } => print_inlined_const(tcx, *did),
+            Self::Local { body, .. } | Self::Anonymous { body, .. } => print_const_expr(tcx, *body),
         }
     }
 
     crate fn value(&self, tcx: TyCtxt<'_>) -> Option<String> {
         match self {
-            Self::TyConst { .. } | Self::Generic { .. } => None,
-            Self::Inline { did, .. } | Self::Const { did, .. } => print_evaluated_const(tcx, *did),
+            Self::TyConst { .. } | Self::Anonymous { .. } => None,
+            Self::Extern { did, .. } | Self::Local { did, .. } => print_evaluated_const(tcx, *did),
         }
     }
 
     crate fn is_literal(&self, tcx: TyCtxt<'_>) -> bool {
         match self {
             Self::TyConst { .. } => false,
-            Self::Inline { did, .. } => did
+            Self::Extern { did, .. } => did
                 .as_local()
                 .map_or(false, |did| is_literal_expr(tcx, tcx.hir().local_def_id_to_hir_id(did))),
-            Self::Const { body, .. } | Self::Generic { body, .. } => {
+            Self::Local { body, .. } | Self::Anonymous { body, .. } => {
                 is_literal_expr(tcx, body.hir_id)
             }
         }
@@ -2031,18 +2032,18 @@ impl Constant {
     crate fn type_(&self) -> &Type {
         match *self {
             Self::TyConst { ref type_, .. }
-            | Self::Inline { ref type_, .. }
-            | Self::Const { ref type_, .. }
-            | Self::Generic { ref type_, .. } => type_,
+            | Self::Extern { ref type_, .. }
+            | Self::Local { ref type_, .. }
+            | Self::Anonymous { ref type_, .. } => type_,
         }
     }
 
     crate fn to_type(self) -> Type {
         match self {
             Self::TyConst { type_, .. }
-            | Self::Inline { type_, .. }
-            | Self::Const { type_, .. }
-            | Self::Generic { type_, .. } => type_,
+            | Self::Extern { type_, .. }
+            | Self::Local { type_, .. }
+            | Self::Anonymous { type_, .. } => type_,
         }
     }
 }