cx.with_param_env(local_did, |cx| {
let inner = match self.kind {
hir::TraitItemKind::Const(ref ty, default) => {
- AssocConstItem(ty.clean(cx), default.map(|e| print_const_expr(cx.tcx, e)))
+ let default =
+ default.map(|e| ConstantKind::Local { def_id: local_did, body: e });
+ AssocConstItem(ty.clean(cx), default)
}
hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => {
let mut m = clean_function(cx, sig, &self.generics, body);
cx.with_param_env(local_did, |cx| {
let inner = match self.kind {
hir::ImplItemKind::Const(ref ty, expr) => {
- AssocConstItem(ty.clean(cx), Some(print_const_expr(cx.tcx, expr)))
+ let default = Some(ConstantKind::Local { def_id: local_did, body: expr });
+ AssocConstItem(ty.clean(cx), default)
}
hir::ImplItemKind::Fn(ref sig, body) => {
let mut m = clean_function(cx, sig, &self.generics, body);
ty::AssocKind::Const => {
let ty = tcx.type_of(self.def_id);
let default = if self.defaultness.has_value() {
- Some(inline::print_inlined_const(tcx, self.def_id))
+ Some(ConstantKind::Extern { def_id: self.def_id })
} else {
None
};
MacroItem(Macro),
ProcMacroItem(ProcMacro),
PrimitiveItem(PrimitiveType),
- AssocConstItem(Type, Option<String>),
+ AssocConstItem(Type, Option<ConstantKind>),
/// An associated item in a trait or trait impl.
///
/// The bounds may be non-empty if there is a `where` clause.
impl Constant {
crate fn expr(&self, tcx: TyCtxt<'_>) -> String {
- match self.kind {
+ self.kind.expr(tcx)
+ }
+
+ crate fn value(&self, tcx: TyCtxt<'_>) -> Option<String> {
+ self.kind.value(tcx)
+ }
+
+ crate fn is_literal(&self, tcx: TyCtxt<'_>) -> bool {
+ self.kind.is_literal(tcx)
+ }
+}
+
+impl ConstantKind {
+ crate fn expr(&self, tcx: TyCtxt<'_>) -> String {
+ match *self {
ConstantKind::TyConst { ref expr } => expr.clone(),
ConstantKind::Extern { def_id } => print_inlined_const(tcx, def_id),
ConstantKind::Local { body, .. } | ConstantKind::Anonymous { body } => {
}
crate fn value(&self, tcx: TyCtxt<'_>) -> Option<String> {
- match self.kind {
+ match *self {
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.kind {
+ match *self {
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))
w: &mut Buffer,
it: &clean::Item,
ty: &clean::Type,
- _default: Option<&String>,
+ _default: Option<&clean::ConstantKind>,
link: AssocItemLink<'_>,
extra: &str,
cx: &Context<'_>,
MacroItem(m) => ItemEnum::Macro(m.source),
ProcMacroItem(m) => ItemEnum::ProcMacro(m.into_tcx(tcx)),
PrimitiveItem(p) => ItemEnum::PrimitiveType(p.as_sym().to_string()),
- AssocConstItem(t, s) => ItemEnum::AssocConst { type_: t.into_tcx(tcx), default: s },
+ AssocConstItem(ty, default) => {
+ ItemEnum::AssocConst { type_: ty.into_tcx(tcx), default: default.map(|c| c.expr(tcx)) }
+ }
AssocTypeItem(g, t) => ItemEnum::AssocType {
bounds: g.into_iter().map(|x| x.into_tcx(tcx)).collect(),
default: t.map(|x| x.into_tcx(tcx)),