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

Revert the rustdoc box syntax removal

Browse Source 
It turned out to cause (minor) perf regressions.
This commit is contained in:
est31 2021-09-21 01:49:47 +02:00
parent 207d9558d0
commit f809ed657c
10 changed files with 47 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -114,7 +114,7 @@ fn generate_for_trait(
attrs: Default::default(),
visibility: Inherited,
def_id: ItemId::Auto { trait_: trait_def_id, for_: item_def_id },
kind: Box::new(ImplItem(Impl {
kind: box ImplItem(Impl {
span: Span::dummy(),
unsafety: hir::Unsafety::Normal,
generics: new_generics,
@ -124,7 +124,7 @@ fn generate_for_trait(
negative_polarity,
synthetic: true,
blanket_impl: None,
})),
}),
cfg: None,
})
}

6
src/librustdoc/clean/blanket_impl.rs
View File

@ -100,7 +100,7 @@ impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> {
attrs: Default::default(),
visibility: Inherited,
def_id: ItemId::Blanket { impl_id: impl_def_id, for_: item_def_id },
kind: Box::new(ImplItem(Impl {
kind: box ImplItem(Impl {
span: Span::new(self.cx.tcx.def_span(impl_def_id)),
unsafety: hir::Unsafety::Normal,
generics: (
@ -121,8 +121,8 @@ impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> {
.clean(self.cx),
negative_polarity: false,
synthetic: false,
blanket_impl: Some(Box::new(trait_ref.self_ty().clean(self.cx))),
})),
blanket_impl: Some(box trait_ref.self_ty().clean(self.cx)),
}),
cfg: None,
});
}

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

@ -124,14 +124,8 @@
let (attrs, cfg) = merge_attrs(cx, Some(parent_module), load_attrs(cx, did), attrs_clone);
cx.inlined.insert(did.into());
let mut item = clean::Item::from_def_id_and_attrs_and_parts(
did,
Some(name),
kind,
Box::new(attrs),
cx,
cfg,
);
let mut item =
clean::Item::from_def_id_and_attrs_and_parts(did, Some(name), kind, box attrs, cx, cfg);
if let Some(import_def_id) = import_def_id {
// The visibility needs to reflect the one from the reexport and not from the "source" DefId.
item.visibility = cx.tcx.visibility(import_def_id).clean(cx);
@ -464,7 +458,7 @@ fn merge_attrs(
synthetic: false,
blanket_impl: None,
}),
Box::new(merged_attrs),
box merged_attrs,
cx,
cfg,
));
@ -493,10 +487,10 @@ fn build_module(
let prim_ty = clean::PrimitiveType::from(p);
items.push(clean::Item {
name: None,
attrs: Box::new(clean::Attributes::default()),
attrs: box clean::Attributes::default(),
def_id: ItemId::Primitive(prim_ty, did.krate),
visibility: clean::Public,
kind: Box::new(clean::ImportItem(clean::Import::new_simple(
kind: box clean::ImportItem(clean::Import::new_simple(
item.ident.name,
clean::ImportSource {
path: clean::Path {
@ -513,7 +507,7 @@ fn build_module(
did: None,
},
true,
))),
)),
cfg: None,
});
} else if let Some(i) = try_inline(cx, did, None, res, item.ident.name, None, visited) {

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

@ -392,8 +392,8 @@ fn clean(&self, cx: &mut DocContext<'_>) -> Type {
Type::QPath {
name: cx.tcx.associated_item(self.item_def_id).ident.name,
self_def_id: self_type.def_id(),
self_type: Box::new(self_type),
trait_: Box::new(trait_),
self_type: box self_type,
trait_: box trait_,
}
}
}
@ -1284,8 +1284,8 @@ fn clean_qpath(hir_ty: &hir::Ty<'_>, cx: &mut DocContext<'_>) -> Type {
Type::QPath {
name: p.segments.last().expect("segments were empty").ident.name,
self_def_id: Some(DefId::local(qself.hir_id.owner.local_def_index)),
self_type: Box::new(qself.clean(cx)),
trait_: Box::new(resolve_type(cx, trait_path)),
self_type: box qself.clean(cx),
trait_: box resolve_type(cx, trait_path),
}
}
hir::QPath::TypeRelative(ref qself, ref segment) => {
@ -1300,8 +1300,8 @@ fn clean_qpath(hir_ty: &hir::Ty<'_>, cx: &mut DocContext<'_>) -> Type {
Type::QPath {
name: segment.ident.name,
self_def_id: res.opt_def_id(),
self_type: Box::new(qself.clean(cx)),
trait_: Box::new(resolve_type(cx, trait_path)),
self_type: box qself.clean(cx),
trait_: box resolve_type(cx, trait_path),
}
}
hir::QPath::LangItem(..) => bug!("clean: requiring documentation of lang item"),
@ -1314,7 +1314,7 @@ fn clean(&self, cx: &mut DocContext<'_>) -> Type {
match self.kind {
TyKind::Never => Never,
TyKind::Ptr(ref m) => RawPointer(m.mutbl, Box::new(m.ty.clean(cx))),
TyKind::Ptr(ref m) => RawPointer(m.mutbl, box m.ty.clean(cx)),
TyKind::Rptr(ref l, ref m) => {
// There are two times a `Fresh` lifetime can be created:
// 1. For `&'_ x`, written by the user. This corresponds to `lower_lifetime` in `rustc_ast_lowering`.
@ -1326,9 +1326,9 @@ fn clean(&self, cx: &mut DocContext<'_>) -> Type {
let elided =
l.is_elided() || matches!(l.name, LifetimeName::Param(ParamName::Fresh(_)));
let lifetime = if elided { None } else { Some(l.clean(cx)) };
BorrowedRef { lifetime, mutability: m.mutbl, type_: Box::new(m.ty.clean(cx)) }
BorrowedRef { lifetime, mutability: m.mutbl, type_: box m.ty.clean(cx) }
}
TyKind::Slice(ref ty) => Slice(Box::new(ty.clean(cx))),
TyKind::Slice(ref ty) => Slice(box ty.clean(cx)),
TyKind::Array(ref ty, ref length) => {
let def_id = cx.tcx.hir().local_def_id(length.hir_id);
// NOTE(min_const_generics): We can't use `const_eval_poly` for constants
@ -1341,7 +1341,7 @@ fn clean(&self, cx: &mut DocContext<'_>) -> Type {
let ct = ty::Const::from_anon_const(cx.tcx, def_id);
let param_env = cx.tcx.param_env(def_id);
let length = print_const(cx, ct.eval(cx.tcx, param_env));
Array(Box::new(ty.clean(cx)), length)
Array(box ty.clean(cx), length)
}
TyKind::Tup(ref tys) => Tuple(tys.clean(cx)),
TyKind::OpaqueDef(item_id, _) => {
@ -1358,7 +1358,7 @@ fn clean(&self, cx: &mut DocContext<'_>) -> Type {
let lifetime = if !lifetime.is_elided() { Some(lifetime.clean(cx)) } else { None };
DynTrait(bounds, lifetime)
}
TyKind::BareFn(ref barefn) => BareFunction(Box::new(barefn.clean(cx))),
TyKind::BareFn(ref barefn) => BareFunction(box barefn.clean(cx)),
// Rustdoc handles `TyKind::Err`s by turning them into `Type::Infer`s.
TyKind::Infer | TyKind::Err => Infer,
TyKind::Typeof(..) => panic!("unimplemented type {:?}", self.kind),
@ -1409,29 +1409,27 @@ fn clean(&self, cx: &mut DocContext<'_>) -> Type {
ty::Uint(uint_ty) => Primitive(uint_ty.into()),
ty::Float(float_ty) => Primitive(float_ty.into()),
ty::Str => Primitive(PrimitiveType::Str),
ty::Slice(ty) => Slice(Box::new(ty.clean(cx))),
ty::Slice(ty) => Slice(box ty.clean(cx)),
ty::Array(ty, n) => {
let mut n = cx.tcx.lift(n).expect("array lift failed");
n = n.eval(cx.tcx, ty::ParamEnv::reveal_all());
let n = print_const(cx, n);
Array(Box::new(ty.clean(cx)), n)
Array(box ty.clean(cx), n)
}
ty::RawPtr(mt) => RawPointer(mt.mutbl, box mt.ty.clean(cx)),
ty::Ref(r, ty, mutbl) => {
BorrowedRef { lifetime: r.clean(cx), mutability: mutbl, type_: box ty.clean(cx) }
}
ty::RawPtr(mt) => RawPointer(mt.mutbl, Box::new(mt.ty.clean(cx))),
ty::Ref(r, ty, mutbl) => BorrowedRef {
lifetime: r.clean(cx),
mutability: mutbl,
type_: Box::new(ty.clean(cx)),
},
ty::FnDef(..) | ty::FnPtr(_) => {
let ty = cx.tcx.lift(*self).expect("FnPtr lift failed");
let sig = ty.fn_sig(cx.tcx);
let def_id = DefId::local(CRATE_DEF_INDEX);
BareFunction(Box::new(BareFunctionDecl {
BareFunction(box BareFunctionDecl {
unsafety: sig.unsafety(),
generic_params: Vec::new(),
decl: (def_id, sig).clean(cx),
abi: sig.abi(),
}))
})
}
ty::Adt(def, substs) => {
let did = def.did;
@ -1974,10 +1972,10 @@ fn clean_extern_crate(
// FIXME: using `from_def_id_and_kind` breaks `rustdoc/masked` for some reason
vec![Item {
name: Some(name),
attrs: Box::new(attrs.clean(cx)),
attrs: box attrs.clean(cx),
def_id: crate_def_id.into(),
visibility: krate.vis.clean(cx),
kind: Box::new(ExternCrateItem { src: orig_name }),
kind: box ExternCrateItem { src: orig_name },
cfg: attrs.cfg(cx.sess()),
}]
}

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

@ -421,7 +421,7 @@ pub fn from_def_id_and_parts(
def_id,
name,
kind,
Box::new(ast_attrs.clean(cx)),
box ast_attrs.clean(cx),
cx,
ast_attrs.cfg(cx.sess()),
)
@ -439,7 +439,7 @@ pub fn from_def_id_and_attrs_and_parts(
Item {
def_id: def_id.into(),
kind: Box::new(kind),
kind: box kind,
name,
attrs,
visibility: cx.tcx.visibility(def_id).clean(cx),

2
src/librustdoc/core.rs
View File

@ -263,7 +263,7 @@ impl<'tcx> DocContext<'tcx> {
stderr: None,
lint_caps,
parse_sess_created: None,
register_lints: Some(Box::new(crate::lint::register_lints)),
register_lints: Some(box crate::lint::register_lints),
override_queries: Some(|_sess, providers, _external_providers| {
// Most lints will require typechecking, so just don't run them.
providers.lint_mod = |_, _| {};

12
src/librustdoc/doctest.rs
View File

@ -99,7 +99,7 @@
stderr: None,
lint_caps,
parse_sess_created: None,
register_lints: Some(Box::new(crate::lint::register_lints)),
register_lints: Some(box crate::lint::register_lints),
override_queries: None,
make_codegen_backend: None,
registry: rustc_driver::diagnostics_registry(),
@ -550,10 +550,10 @@ fn drop(&mut self) {
.supports_color();
let emitter =
EmitterWriter::new(Box::new(io::sink()), None, false, false, false, None, false);
EmitterWriter::new(box io::sink(), None, false, false, false, None, false);
// FIXME(misdreavus): pass `-Z treat-err-as-bug` to the doctest parser
let handler = Handler::with_emitter(false, None, Box::new(emitter));
let handler = Handler::with_emitter(false, None, box emitter);
let sess = ParseSess::with_span_handler(handler, sm);
let mut found_main = false;
@ -963,7 +963,7 @@ fn add_test(&mut self, test: String, config: LangString, line: usize) {
no_run,
test_type: test::TestType::DocTest,
},
testfn: test::DynTestFn(Box::new(move || {
testfn: test::DynTestFn(box move || {
let report_unused_externs = |uext| {
unused_externs.lock().unwrap().push(uext);
};
@ -1043,9 +1043,9 @@ fn add_test(&mut self, test: String, config: LangString, line: usize) {
}
}
panic::resume_unwind(Box::new(()));
panic::resume_unwind(box ());
}
})),
}),
});
}

8
src/librustdoc/fold.rs
View File

@ -2,7 +2,7 @@
crate fn strip_item(mut item: Item) -> Item {
if !matches!(*item.kind, StrippedItem(..)) {
item.kind = Box::new(StrippedItem(item.kind));
item.kind = box StrippedItem(item.kind);
}
item
}
@ -69,10 +69,10 @@ fn fold_inner_recur(&mut self, kind: ItemKind) -> ItemKind {
/// don't override!
fn fold_item_recur(&mut self, mut item: Item) -> Item {
item.kind = Box::new(match *item.kind {
StrippedItem(box i) => StrippedItem(Box::new(self.fold_inner_recur(i))),
item.kind = box match *item.kind {
StrippedItem(box i) => StrippedItem(box self.fold_inner_recur(i)),
_ => self.fold_inner_recur(*item.kind),
});
};
item
}

1
src/librustdoc/lib.rs
View File

@ -7,6 +7,7 @@
#![feature(assert_matches)]
#![feature(box_patterns)]
#![feature(control_flow_enum)]
#![feature(box_syntax)]
#![feature(in_band_lifetimes)]
#![feature(nll)]
#![feature(test)]

2
src/librustdoc/passes/collect_intra_doc_links.rs
View File

@ -64,7 +64,7 @@ enum ErrorKind<'a> {
impl<'a> From<ResolutionFailure<'a>> for ErrorKind<'a> {
fn from(err: ResolutionFailure<'a>) -> Self {
ErrorKind::Resolve(Box::new(err))
ErrorKind::Resolve(box err)
}
}