mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rustdoc: use ThinVec and Box<str> to shrink clean::ItemKind

Browse Source
This commit is contained in:
Michael Howell 2022-11-05 09:02:10 -07:00
parent 09508489ef
commit a69d43493a
5 changed files with 16 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/librustdoc/clean/inline.rs
View File

@ -3,7 +3,7 @@
use std::iter::once;
use std::sync::Arc;
use thin_vec::ThinVec;
use thin_vec::{thin_vec, ThinVec};
use rustc_ast as ast;
use rustc_data_structures::fx::FxHashSet;
@ -596,7 +596,7 @@ fn build_module_items(
clean::ImportSource {
path: clean::Path {
res,
segments: vec![clean::PathSegment {
segments: thin_vec![clean::PathSegment {
name: prim_ty.as_sym(),
args: clean::GenericArgs::AngleBracketed {
args: Default::default(),

8
src/librustdoc/clean/mod.rs
View File

@ -227,7 +227,7 @@ pub(crate) fn clean_middle_const<'tcx>(
// FIXME: instead of storing the stringified expression, store `self` directly instead.
Constant {
type_: clean_middle_ty(constant.ty(), cx, None),
kind: ConstantKind::TyConst { expr: constant.to_string() },
kind: ConstantKind::TyConst { expr: constant.to_string().into() },
}
}
@ -1200,7 +1200,7 @@ fn param_eq_arg(param: &GenericParamDef, arg: &GenericArg) -> bool {
true
}
(GenericParamDefKind::Const { .. }, GenericArg::Const(c)) => match &c.kind {
ConstantKind::TyConst { expr } => expr == param.name.as_str(),
ConstantKind::TyConst { expr } => **expr == *param.name.as_str(),
_ => false,
},
_ => false,
@ -1529,7 +1529,7 @@ pub(crate) fn clean_ty<'tcx>(ty: &hir::Ty<'tcx>, cx: &mut DocContext<'tcx>) -> T
}
};
Array(Box::new(clean_ty(ty, cx)), length)
Array(Box::new(clean_ty(ty, cx)), length.into())
}
TyKind::Tup(tys) => Tuple(tys.iter().map(|ty| clean_ty(ty, cx)).collect()),
TyKind::OpaqueDef(item_id, _, _) => {
@ -1601,7 +1601,7 @@ pub(crate) fn clean_middle_ty<'tcx>(
ty::Array(ty, mut n) => {
n = n.eval(cx.tcx, ty::ParamEnv::reveal_all());
let n = print_const(cx, n);
Array(Box::new(clean_middle_ty(ty, cx, None)), n)
Array(Box::new(clean_middle_ty(ty, cx, None)), n.into())
}
ty::RawPtr(mt) => RawPointer(mt.mutbl, Box::new(clean_middle_ty(mt.ty, cx, None))),
ty::Ref(r, ty, mutbl) => BorrowedRef {

14
src/librustdoc/clean/types.rs
View File

@ -1621,7 +1621,7 @@ pub(crate) enum Type {
/// An array type.
///
/// The `String` field is a stringified version of the array's length parameter.
Array(Box<Type>, String),
Array(Box<Type>, Box<str>),
/// A raw pointer type: `*const i32`, `*mut i32`
RawPointer(Mutability, Box<Type>),
/// A reference type: `&i32`, `&'a mut Foo`
@ -2206,7 +2206,7 @@ pub(crate) fn cnum(&self, sess: &Session) -> CrateNum {
#[derive(Clone, PartialEq, Eq, Debug, Hash)]
pub(crate) struct Path {
pub(crate) res: Res,
pub(crate) segments: Vec<PathSegment>,
pub(crate) segments: ThinVec<PathSegment>,
}
impl Path {
@ -2356,7 +2356,7 @@ pub(crate) enum ConstantKind {
///
/// 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 },
TyConst { expr: Box<str> },
/// 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.
@ -2384,7 +2384,7 @@ pub(crate) fn is_literal(&self, tcx: TyCtxt<'_>) -> bool {
impl ConstantKind {
pub(crate) fn expr(&self, tcx: TyCtxt<'_>) -> String {
match *self {
ConstantKind::TyConst { ref expr } => expr.clone(),
ConstantKind::TyConst { ref expr } => expr.to_string(),
ConstantKind::Extern { def_id } => print_inlined_const(tcx, def_id),
ConstantKind::Local { body, .. } | ConstantKind::Anonymous { body } => {
print_const_expr(tcx, body)
@ -2570,13 +2570,13 @@ mod size_asserts {
// tidy-alphabetical-start
static_assert_size!(Crate, 72); // frequently moved by-value
static_assert_size!(DocFragment, 32);
static_assert_size!(GenericArg, 48);
static_assert_size!(GenericArg, 32);
static_assert_size!(GenericArgs, 32);
static_assert_size!(GenericParamDef, 56);
static_assert_size!(Generics, 16);
static_assert_size!(Item, 56);
static_assert_size!(ItemKind, 88);
static_assert_size!(ItemKind, 64);
static_assert_size!(PathSegment, 40);
static_assert_size!(Type, 48);
static_assert_size!(Type, 32);
// tidy-alphabetical-end
}

4
src/librustdoc/clean/utils.rs
View File

@ -21,7 +21,7 @@
use rustc_span::symbol::{kw, sym, Symbol};
use std::fmt::Write as _;
use std::mem;
use thin_vec::ThinVec;
use thin_vec::{thin_vec, ThinVec};
#[cfg(test)]
mod tests;
@ -136,7 +136,7 @@ pub(super) fn external_path<'tcx>(
let name = cx.tcx.item_name(did);
Path {
res: Res::Def(def_kind, did),
segments: vec![PathSegment {
segments: thin_vec![PathSegment {
name,
args: external_generic_args(cx, did, has_self, bindings, substs),
}],

2
src/librustdoc/json/conversions.rs
View File

@ -485,7 +485,7 @@ fn from_tcx(ty: clean::Type, tcx: TyCtxt<'_>) -> Self {
BareFunction(f) => Type::FunctionPointer(Box::new((*f).into_tcx(tcx))),
Tuple(t) => Type::Tuple(t.into_tcx(tcx)),
Slice(t) => Type::Slice(Box::new((*t).into_tcx(tcx))),
Array(t, s) => Type::Array { type_: Box::new((*t).into_tcx(tcx)), len: s },
Array(t, s) => Type::Array { type_: Box::new((*t).into_tcx(tcx)), len: s.to_string() },
ImplTrait(g) => Type::ImplTrait(g.into_tcx(tcx)),
Infer => Type::Infer,
RawPointer(mutability, type_) => Type::RawPointer {