Skip to content

Commit

Permalink
Split clean::Constant enum into a struct and an enum
Browse files Browse the repository at this point in the history
  • Loading branch information
GuillaumeGomez committed Mar 24, 2021
1 parent ee50933 commit 7b59089
Show file tree
Hide file tree
Showing 5 changed files with 46 additions and 46 deletions.
5 changes: 4 additions & 1 deletion src/librustdoc/clean/inline.rs
Original file line number Diff line number Diff line change
Expand Up @@ -500,7 +500,10 @@ crate fn print_inlined_const(tcx: TyCtxt<'_>, did: DefId) -> String {
}

fn build_const(cx: &mut DocContext<'_>, def_id: DefId) -> clean::Constant {
clean::Constant::Extern { type_: cx.tcx.type_of(def_id).clean(cx), def_id }
clean::Constant {
type_: cx.tcx.type_of(def_id).clean(cx),
kind: clean::ConstantKind::Extern { def_id },
}
}

fn build_static(cx: &mut DocContext<'_>, did: DefId, mutable: bool) -> clean::Static {
Expand Down
16 changes: 10 additions & 6 deletions src/librustdoc/clean/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -393,12 +393,12 @@ impl Clean<Lifetime> for hir::GenericParam<'_> {

impl Clean<Constant> for hir::ConstArg {
fn clean(&self, cx: &mut DocContext<'_>) -> Constant {
Constant::Anonymous {
Constant {
type_: cx
.tcx
.type_of(cx.tcx.hir().body_owner_def_id(self.value.body).to_def_id())
.clean(cx),
body: self.value.body,
kind: ConstantKind::Anonymous { body: self.value.body },
}
}
}
Expand Down Expand Up @@ -1744,7 +1744,10 @@ impl<'tcx> Clean<Type> for Ty<'tcx> {
impl<'tcx> Clean<Constant> for ty::Const<'tcx> {
fn clean(&self, cx: &mut DocContext<'_>) -> Constant {
// FIXME: instead of storing the stringified expression, store `self` directly instead.
Constant::TyConst { type_: self.ty.clean(cx), expr: self.to_string() }
Constant {
type_: self.ty.clean(cx),
kind: ConstantKind::TyConst { expr: self.to_string() },
}
}
}

Expand Down Expand Up @@ -1945,9 +1948,10 @@ 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::Local { type_: ty.clean(cx), body: body_id, def_id })
}
ItemKind::Const(ty, body_id) => ConstantItem(Constant {
type_: ty.clean(cx),
kind: ConstantKind::Local { body: body_id, def_id },
}),
ItemKind::OpaqueTy(ref ty) => OpaqueTyItem(OpaqueTy {
bounds: ty.bounds.clean(cx),
generics: ty.generics.clean(cx),
Expand Down
67 changes: 30 additions & 37 deletions src/librustdoc/clean/types.rs
Original file line number Diff line number Diff line change
Expand Up @@ -1987,67 +1987,60 @@ crate struct Static {
}

#[derive(Clone, PartialEq, Eq, Hash, Debug)]
crate enum Constant {
crate struct Constant {
crate type_: Type,
crate kind: ConstantKind,
}

#[derive(Clone, PartialEq, Eq, Hash, Debug)]
crate enum ConstantKind {
/// 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
///
/// Note that `ty::Const` includes generic parameters, and may not always be uniquely identified
/// by a DefId. So this field must be different from `Extern`.
TyConst { 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.
Anonymous { type_: Type, body: BodyId },
Anonymous { body: BodyId },
/// A constant from a different crate.
Extern { type_: Type, def_id: DefId },
/// const FOO: u32 = ...;
Local { type_: Type, def_id: DefId, body: BodyId },
Extern { def_id: DefId },
/// `const FOO: u32 = ...;`
Local { def_id: DefId, body: BodyId },
}

impl Constant {
crate fn expr(&self, tcx: TyCtxt<'_>) -> String {
match self {
Self::TyConst { expr, .. } => expr.clone(),
Self::Extern { def_id, .. } => print_inlined_const(tcx, *def_id),
Self::Local { body, .. } | Self::Anonymous { body, .. } => print_const_expr(tcx, *body),
match self.kind {
ConstantKind::TyConst { ref expr } => expr.clone(),
ConstantKind::Extern { def_id } => print_inlined_const(tcx, def_id),
ConstantKind::Local { body, .. } | ConstantKind::Anonymous { body } => {
print_const_expr(tcx, body)
}
}
}

crate fn value(&self, tcx: TyCtxt<'_>) -> Option<String> {
match self {
Self::TyConst { .. } | Self::Anonymous { .. } => None,
Self::Extern { def_id, .. } | Self::Local { def_id, .. } => {
print_evaluated_const(tcx, *def_id)
match self.kind {
ConstantKind::TyConst { .. } | ConstantKind::Anonymous { .. } => None,
ConstantKind::Extern { def_id } | ConstantKind::Local { def_id, .. } => {
print_evaluated_const(tcx, def_id)
}
}
}

crate fn is_literal(&self, tcx: TyCtxt<'_>) -> bool {
match self {
Self::TyConst { .. } => false,
Self::Extern { def_id, .. } => def_id.as_local().map_or(false, |def_id| {
match self.kind {
ConstantKind::TyConst { .. } => false,
ConstantKind::Extern { def_id } => def_id.as_local().map_or(false, |def_id| {
is_literal_expr(tcx, tcx.hir().local_def_id_to_hir_id(def_id))
}),
Self::Local { body, .. } | Self::Anonymous { body, .. } => {
ConstantKind::Local { body, .. } | ConstantKind::Anonymous { body } => {
is_literal_expr(tcx, body.hir_id)
}
}
}

crate fn type_(&self) -> &Type {
match *self {
Self::TyConst { ref 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::Extern { type_, .. }
| Self::Local { type_, .. }
| Self::Anonymous { type_, .. } => type_,
}
}
}

#[derive(Clone, Debug)]
Expand Down
2 changes: 1 addition & 1 deletion src/librustdoc/html/render/print_item.rs
Original file line number Diff line number Diff line change
Expand Up @@ -982,7 +982,7 @@ fn item_constant(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, c: &clean::
"{vis}const {name}: {typ}",
vis = it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
name = it.name.as_ref().unwrap(),
typ = c.type_().print(cx.cache(), cx.tcx()),
typ = c.type_.print(cx.cache(), cx.tcx()),
);

let value = c.value(cx.tcx());
Expand Down
2 changes: 1 addition & 1 deletion src/librustdoc/json/conversions.rs
Original file line number Diff line number Diff line change
Expand Up @@ -142,7 +142,7 @@ impl FromWithTcx<clean::Constant> for Constant {
let expr = constant.expr(tcx);
let value = constant.value(tcx);
let is_literal = constant.is_literal(tcx);
Constant { type_: constant.to_type().into_tcx(tcx), expr, value, is_literal }
Constant { type_: constant.type_.into_tcx(tcx), expr, value, is_literal }
}
}

Expand Down

0 comments on commit 7b59089

Please sign in to comment.