diff --git a/src/librustdoc/clean/cfg.rs b/src/librustdoc/clean/cfg.rs
index ec3407d361ebd..5dc9f17c15fdb 100644
--- a/src/librustdoc/clean/cfg.rs
+++ b/src/librustdoc/clean/cfg.rs
@@ -149,7 +149,7 @@ impl Cfg {
             | CfgEntry::All(..)
             | CfgEntry::NameValue { .. }
             | CfgEntry::Version(..)
-            | CfgEntry::Not(box CfgEntry::NameValue { .. }, _) => true,
+            | CfgEntry::Not(CfgEntry::NameValue { .. }, _) => true,
             CfgEntry::Not(..) | CfgEntry::Bool(..) => false,
         }
     }
@@ -386,7 +386,7 @@ impl Display<'_> {
 impl fmt::Display for Display<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self.0 {
-            CfgEntry::Not(box CfgEntry::Any(sub_cfgs, _), _) => {
+            CfgEntry::Not(CfgEntry::Any(sub_cfgs, _), _) => {
                 let separator = if sub_cfgs.iter().all(is_simple_cfg) { " nor " } else { ", nor " };
                 fmt.write_str("neither ")?;
 
@@ -399,10 +399,10 @@ impl fmt::Display for Display<'_> {
                     })
                     .joined(separator, fmt)
             }
-            CfgEntry::Not(box simple @ CfgEntry::NameValue { .. }, _) => {
+            CfgEntry::Not(simple @ CfgEntry::NameValue { .. }, _) => {
                 write!(fmt, "non-{}", Display(simple, self.1))
             }
-            CfgEntry::Not(box c, _) => write!(fmt, "not ({})", Display(c, self.1)),
+            CfgEntry::Not(c, _) => write!(fmt, "not ({})", Display(c, self.1)),
 
             CfgEntry::Any(sub_cfgs, _) => {
                 let separator = if sub_cfgs.iter().all(is_simple_cfg) { " or " } else { ", or " };
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index f020a26a23bc2..d50e4dd80557a 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1472,11 +1472,8 @@ pub(crate) fn clean_middle_assoc_item(assoc_item: &ty::AssocItem, cx: &mut DocCo
                 generics.where_predicates.retain_mut(|pred| match *pred {
                     WherePredicate::BoundPredicate {
                         ty:
-                            QPath(box QPathData {
-                                ref assoc,
-                                ref self_type,
-                                trait_: Some(ref trait_),
-                                ..
+                            QPath(QPathData {
+                                ref assoc, ref self_type, trait_: Some(ref trait_), ..
                             }),
                         bounds: ref mut pred_bounds,
                         ..
@@ -2786,7 +2783,7 @@ fn add_without_unwanted_attributes<'hir>(
             hir::Attribute::Parsed(AttributeKind::DocComment { .. }) => {
                 attrs.push((Cow::Borrowed(attr), import_parent));
             }
-            hir::Attribute::Parsed(AttributeKind::Doc(box d)) => {
+            hir::Attribute::Parsed(AttributeKind::Doc(d)) => {
                 // Remove attributes from `normal` that should not be inherited by `use` re-export.
                 let DocAttribute {
                     first_span: _,
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 05d4888c110cc..7b7fbffbe9066 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -491,7 +491,7 @@ impl Item {
 
     /// Returns true if item is an associated function with a `self` parameter.
     pub(crate) fn has_self_param(&self) -> bool {
-        if let ItemKind::MethodItem(box Function { decl, .. }, _) = &self.inner.kind {
+        if let ItemKind::MethodItem(Function { decl, .. }, _) = &self.inner.kind {
             decl.receiver_type().is_some()
         } else {
             false
@@ -505,8 +505,8 @@ impl Item {
         };
         match kind {
             ItemKind::ModuleItem(Module { span, .. }) => Some(*span),
-            ItemKind::ImplItem(box Impl { kind: ImplKind::Auto, .. }) => None,
-            ItemKind::ImplItem(box Impl { kind: ImplKind::Blanket(_), .. }) => {
+            ItemKind::ImplItem(Impl { kind: ImplKind::Auto, .. }) => None,
+            ItemKind::ImplItem(Impl { kind: ImplKind::Blanket(_), .. }) => {
                 if let ItemId::Blanket { impl_id, .. } = self.item_id {
                     Some(rustc_span(impl_id, tcx))
                 } else {
@@ -667,16 +667,21 @@ impl Item {
         self.type_() == ItemType::Variant
     }
     pub(crate) fn is_associated_type(&self) -> bool {
-        matches!(self.kind, AssocTypeItem(..) | StrippedItem(box AssocTypeItem(..)))
+        matches!(self.kind, AssocTypeItem(..) | StrippedItem(AssocTypeItem(..)))
     }
     pub(crate) fn is_required_associated_type(&self) -> bool {
-        matches!(self.kind, RequiredAssocTypeItem(..) | StrippedItem(box RequiredAssocTypeItem(..)))
+        matches!(self.kind, RequiredAssocTypeItem(..) | StrippedItem(RequiredAssocTypeItem(..)))
     }
     pub(crate) fn is_associated_const(&self) -> bool {
-        matches!(self.kind, ProvidedAssocConstItem(..) | ImplAssocConstItem(..) | StrippedItem(box (ProvidedAssocConstItem(..) | ImplAssocConstItem(..))))
+        matches!(
+            self.kind,
+            ProvidedAssocConstItem(..)
+                | ImplAssocConstItem(..)
+                | StrippedItem(ProvidedAssocConstItem(..) | ImplAssocConstItem(..))
+        )
     }
     pub(crate) fn is_required_associated_const(&self) -> bool {
-        matches!(self.kind, RequiredAssocConstItem(..) | StrippedItem(box RequiredAssocConstItem(..)))
+        matches!(self.kind, RequiredAssocConstItem(..) | StrippedItem(RequiredAssocConstItem(..)))
     }
     pub(crate) fn is_method(&self) -> bool {
         self.type_() == ItemType::Method
@@ -1508,9 +1513,9 @@ impl Type {
 
     pub(crate) fn primitive_type(&self) -> Option<PrimitiveType> {
         match *self {
-            Primitive(p) | BorrowedRef { type_: box Primitive(p), .. } => Some(p),
-            Slice(..) | BorrowedRef { type_: box Slice(..), .. } => Some(PrimitiveType::Slice),
-            Array(..) | BorrowedRef { type_: box Array(..), .. } => Some(PrimitiveType::Array),
+            Primitive(p) | BorrowedRef { type_: Primitive(p), .. } => Some(p),
+            Slice(..) | BorrowedRef { type_: Slice(..), .. } => Some(PrimitiveType::Slice),
+            Array(..) | BorrowedRef { type_: Array(..), .. } => Some(PrimitiveType::Array),
             Tuple(ref tys) => {
                 if tys.is_empty() {
                     Some(PrimitiveType::Unit)
@@ -1590,7 +1595,7 @@ impl Type {
             Type::Path { path } => return Some(path.def_id()),
             DynTrait(bounds, _) => return bounds.first().map(|b| b.trait_.def_id()),
             Primitive(p) => return cache.primitive_locations.get(p).cloned(),
-            BorrowedRef { type_: box Generic(..), .. } => PrimitiveType::Reference,
+            BorrowedRef { type_: Generic(..), .. } => PrimitiveType::Reference,
             BorrowedRef { type_, .. } => return type_.def_id(cache),
             Tuple(tys) => {
                 if tys.is_empty() {
@@ -1605,7 +1610,7 @@ impl Type {
             Type::Pat(..) => PrimitiveType::Pat,
             Type::FieldOf(..) => PrimitiveType::FieldOf,
             RawPointer(..) => PrimitiveType::RawPointer,
-            QPath(box QPathData { self_type, .. }) => return self_type.def_id(cache),
+            QPath(QPathData { self_type, .. }) => return self_type.def_id(cache),
             Generic(_) | SelfTy | Infer | ImplTrait(_) | UnsafeBinder(_) => return None,
         };
         Primitive(t).def_id(cache)
diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs
index 8b9db4638e473..3890eccc402a7 100644
--- a/src/librustdoc/fold.rs
+++ b/src/librustdoc/fold.rs
@@ -105,7 +105,7 @@ pub(crate) trait DocFolder: Sized {
     /// don't override!
     fn fold_item_recur(&mut self, mut item: Item) -> Item {
         item.inner.kind = match item.inner.kind {
-            StrippedItem(box i) => StrippedItem(Box::new(self.fold_inner_recur(i))),
+            StrippedItem(i) => StrippedItem(Box::new(self.fold_inner_recur(*i))),
             _ => self.fold_inner_recur(item.inner.kind),
         };
         item
diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
index 18b00224dfcb0..0312f8909c036 100644
--- a/src/librustdoc/formats/cache.rs
+++ b/src/librustdoc/formats/cache.rs
@@ -248,7 +248,7 @@ impl DocFolder for CacheBuilder<'_, '_> {
         // If this is a stripped module,
         // we don't want it or its children in the search index.
         let orig_stripped_mod = match item.kind {
-            clean::StrippedItem(box clean::ModuleItem(..)) => {
+            clean::StrippedItem(clean::ModuleItem(..)) => {
                 mem::replace(&mut self.cache.stripped_mod, true)
             }
             _ => self.cache.stripped_mod,
@@ -409,69 +409,69 @@ impl DocFolder for CacheBuilder<'_, '_> {
 
         // Once we've recursively found all the generics, hoard off all the
         // implementations elsewhere.
-        let ret = if let clean::Item {
-            inner: box clean::ItemInner { kind: clean::ImplItem(ref i), .. },
-        } = item
-        {
-            // Figure out the id of this impl. This may map to a
-            // primitive rather than always to a struct/enum.
-            // Note: matching twice to restrict the lifetime of the `i` borrow.
-            let mut dids = FxIndexSet::default();
-            match i.for_ {
-                clean::Type::Path { ref path }
-                | clean::BorrowedRef { type_: box clean::Type::Path { ref path }, .. } => {
-                    dids.insert(path.def_id());
-                    if let Some(generics) = path.generics()
-                        && let ty::Adt(adt, _) = self
-                            .tcx
-                            .type_of(path.def_id())
-                            .instantiate_identity()
-                            .skip_norm_wip()
-                            .kind()
-                        && adt.is_fundamental()
-                    {
-                        for ty in generics {
-                            dids.extend(ty.def_id(self.cache));
+        let ret =
+            if let clean::Item { inner: clean::ItemInner { kind: clean::ImplItem(ref i), .. } } =
+                item
+            {
+                // Figure out the id of this impl. This may map to a
+                // primitive rather than always to a struct/enum.
+                // Note: matching twice to restrict the lifetime of the `i` borrow.
+                let mut dids = FxIndexSet::default();
+                match i.for_ {
+                    clean::Type::Path { ref path }
+                    | clean::BorrowedRef { type_: clean::Type::Path { ref path }, .. } => {
+                        dids.insert(path.def_id());
+                        if let Some(generics) = path.generics()
+                            && let ty::Adt(adt, _) = self
+                                .tcx
+                                .type_of(path.def_id())
+                                .instantiate_identity()
+                                .skip_norm_wip()
+                                .kind()
+                            && adt.is_fundamental()
+                        {
+                            for ty in generics {
+                                dids.extend(ty.def_id(self.cache));
+                            }
                         }
                     }
-                }
-                clean::DynTrait(ref bounds, _)
-                | clean::BorrowedRef { type_: box clean::DynTrait(ref bounds, _), .. } => {
-                    dids.insert(bounds[0].trait_.def_id());
-                }
-                ref t => {
-                    let did = t
-                        .primitive_type()
-                        .and_then(|t| self.cache.primitive_locations.get(&t).cloned());
+                    clean::DynTrait(ref bounds, _)
+                    | clean::BorrowedRef { type_: clean::DynTrait(ref bounds, _), .. } => {
+                        dids.insert(bounds[0].trait_.def_id());
+                    }
+                    ref t => {
+                        let did = t
+                            .primitive_type()
+                            .and_then(|t| self.cache.primitive_locations.get(&t).cloned());
 
-                    dids.extend(did);
+                        dids.extend(did);
+                    }
                 }
-            }
 
-            if let Some(trait_) = &i.trait_
-                && let Some(generics) = trait_.generics()
-            {
-                for bound in generics {
-                    dids.extend(bound.def_id(self.cache));
+                if let Some(trait_) = &i.trait_
+                    && let Some(generics) = trait_.generics()
+                {
+                    for bound in generics {
+                        dids.extend(bound.def_id(self.cache));
+                    }
                 }
-            }
-            let impl_item = Impl { impl_item: item };
-            let impl_did = impl_item.def_id();
-            let trait_did = impl_item.trait_did();
-            if trait_did.is_none_or(|d| self.cache.traits.contains_key(&d)) {
-                for did in dids {
-                    if self.impl_ids.entry(did).or_default().insert(impl_did) {
-                        self.cache.impls.entry(did).or_default().push(impl_item.clone());
+                let impl_item = Impl { impl_item: item };
+                let impl_did = impl_item.def_id();
+                let trait_did = impl_item.trait_did();
+                if trait_did.is_none_or(|d| self.cache.traits.contains_key(&d)) {
+                    for did in dids {
+                        if self.impl_ids.entry(did).or_default().insert(impl_did) {
+                            self.cache.impls.entry(did).or_default().push(impl_item.clone());
+                        }
                     }
+                } else {
+                    let trait_did = trait_did.expect("no trait did");
+                    self.cache.orphan_trait_impls.push((trait_did, dids, impl_item));
                 }
+                None
             } else {
-                let trait_did = trait_did.expect("no trait did");
-                self.cache.orphan_trait_impls.push((trait_did, dids, impl_item));
-            }
-            None
-        } else {
-            Some(item)
-        };
+                Some(item)
+            };
 
         if pushed {
             self.cache.stack.pop().expect("stack already empty");
@@ -655,7 +655,7 @@ enum ParentStackItem {
 impl ParentStackItem {
     fn new(item: &clean::Item) -> Self {
         match &item.kind {
-            clean::ItemKind::ImplItem(box clean::Impl { for_, trait_, generics, kind, .. }) => {
+            clean::ItemKind::ImplItem(clean::Impl { for_, trait_, generics, kind, .. }) => {
                 ParentStackItem::Impl {
                     for_: for_.clone(),
                     trait_: trait_.clone(),
diff --git a/src/librustdoc/formats/item_type.rs b/src/librustdoc/formats/item_type.rs
index eb3492e4625be..73b85d2923619 100644
--- a/src/librustdoc/formats/item_type.rs
+++ b/src/librustdoc/formats/item_type.rs
@@ -106,7 +106,7 @@ item_type! {
 impl<'a> From<&'a clean::Item> for ItemType {
     fn from(item: &'a clean::Item) -> ItemType {
         let kind = match &item.kind {
-            clean::StrippedItem(box item) => item,
+            clean::StrippedItem(item) => item,
             kind => kind,
         };
 
diff --git a/src/librustdoc/formats/renderer.rs b/src/librustdoc/formats/renderer.rs
index 5c458232f8f9c..bb2ccf0d4a354 100644
--- a/src/librustdoc/formats/renderer.rs
+++ b/src/librustdoc/formats/renderer.rs
@@ -75,8 +75,8 @@ fn run_format_inner<'tcx, T: FormatRenderer<'tcx>>(
             prof.generic_activity_with_arg("render_mod_item", item.name.unwrap().to_string());
 
         cx.mod_item_in(item)?;
-        let (clean::StrippedItem(box clean::ModuleItem(ref module))
-        | clean::ModuleItem(ref module)) = item.inner.kind
+        let (clean::StrippedItem(clean::ModuleItem(ref module)) | clean::ModuleItem(ref module)) =
+            item.inner.kind
         else {
             unreachable!()
         };
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 0694dd05cd399..35212d480cfdd 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -961,7 +961,7 @@ fn fmt_type(
                 }
             }
         },
-        clean::Slice(box clean::Generic(name)) => {
+        clean::Slice(clean::Generic(name)) => {
             primitive_link(f, PrimitiveType::Slice, format_args!("[{name}]"), cx)
         }
         clean::Slice(t) => Wrapped::with_square_brackets().wrap(print_type(t, cx)).fmt(f),
@@ -974,7 +974,7 @@ fn fmt_type(
             fmt::Display::fmt(&print_type(t, cx), f)?;
             write!(f, ", {field})")
         }
-        clean::Array(box clean::Generic(name), n) if !f.alternate() => primitive_link(
+        clean::Array(clean::Generic(name), n) if !f.alternate() => primitive_link(
             f,
             PrimitiveType::Array,
             format_args!("[{name}; {n}]", n = Escape(n)),
@@ -1280,7 +1280,7 @@ fn print_parameter(parameter: &clean::Parameter, cx: &Context<'_>) -> impl fmt::
         if let Some(self_ty) = parameter.to_receiver() {
             match self_ty {
                 clean::SelfTy => f.write_str("self"),
-                clean::BorrowedRef { lifetime, mutability, type_: box clean::SelfTy } => {
+                clean::BorrowedRef { lifetime, mutability, type_: clean::SelfTy } => {
                     f.write_str(if f.alternate() { "&" } else { "&amp;" })?;
                     if let Some(lt) = lifetime {
                         write!(f, "{lt} ", lt = print_lifetime(lt))?;
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index 6c02eecbd06ee..038eb49407f84 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -832,7 +832,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
 
         // Render sidebar-items.js used throughout this module.
         if !self.info.render_redirect_pages {
-            let (clean::StrippedItem(box clean::ModuleItem(ref module))
+            let (clean::StrippedItem(clean::ModuleItem(ref module))
             | clean::ModuleItem(ref module)) = item.kind
             else {
                 unreachable!()
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 8600fccdbe62c..20bbf96559789 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -809,7 +809,8 @@ fn document_full_inner(
         }
 
         let kind = match &item.kind {
-            clean::ItemKind::StrippedItem(box kind) | kind => kind,
+            clean::ItemKind::StrippedItem(kind) => kind,
+            kind => kind,
         };
 
         if let clean::ItemKind::FunctionItem(..) | clean::ItemKind::MethodItem(..) = kind {
@@ -1582,7 +1583,7 @@ fn render_deref_methods(
         .items
         .iter()
         .find_map(|item| match item.kind {
-            clean::AssocTypeItem(box ref t, _) => Some(match *t {
+            clean::AssocTypeItem(ref t, _) => Some(match *t {
                 clean::TypeAlias { item_type: Some(ref type_), .. } => (type_, &t.type_),
                 _ => (&t.type_, &t.type_),
             }),
@@ -2709,7 +2710,7 @@ fn collect_paths_for_type(first_ty: &clean::Type, cache: &Cache) -> Vec<String>
             clean::Type::BorrowedRef { type_, .. } => {
                 work.push_back(type_);
             }
-            clean::Type::QPath(box clean::QPathData { self_type, trait_, .. }) => {
+            clean::Type::QPath(clean::QPathData { self_type, trait_, .. }) => {
                 work.push_back(self_type);
                 if let Some(trait_) = trait_ {
                     process_path(trait_.def_id());
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index 48108097864a4..870c60a984813 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -1524,9 +1524,8 @@ fn item_union(cx: &Context<'_>, it: &clean::Item, s: &clean::Union) -> impl fmt:
 fn print_tuple_struct_fields(cx: &Context<'_>, s: &[clean::Item]) -> impl Display {
     fmt::from_fn(|f| {
         if !s.is_empty()
-            && s.iter().all(|field| {
-                matches!(field.kind, clean::StrippedItem(box clean::StructFieldItem(..)))
-            })
+            && s.iter()
+                .all(|field| matches!(field.kind, clean::StrippedItem(clean::StructFieldItem(..))))
         {
             return f.write_str("<span class=\"comment\">/* private fields */</span>");
         }
@@ -1534,7 +1533,7 @@ fn print_tuple_struct_fields(cx: &Context<'_>, s: &[clean::Item]) -> impl Displa
         s.iter()
             .map(|ty| {
                 fmt::from_fn(|f| match ty.kind {
-                    clean::StrippedItem(box clean::StructFieldItem(_)) => f.write_str("_"),
+                    clean::StrippedItem(clean::StructFieldItem(_)) => f.write_str("_"),
                     clean::StructFieldItem(ref ty) => write!(f, "{}", print_type(ty, cx)),
                     _ => unreachable!(),
                 })
@@ -1852,7 +1851,7 @@ fn item_variants(
                 )?;
                 for field in fields {
                     match field.kind {
-                        clean::StrippedItem(box clean::StructFieldItem(_)) => {}
+                        clean::StrippedItem(clean::StructFieldItem(_)) => {}
                         clean::StructFieldItem(ref ty) => {
                             let id = cx.derive_id(format!(
                                 "variant.{}.field.{}",
@@ -2355,7 +2354,7 @@ fn render_implementor(
     // full path, for example in `std::iter::ExactSizeIterator`
     let use_absolute = match implementor.inner_impl().for_ {
         clean::Type::Path { ref path, .. }
-        | clean::BorrowedRef { type_: box clean::Type::Path { ref path, .. }, .. }
+        | clean::BorrowedRef { type_: clean::Type::Path { ref path, .. }, .. }
             if !path.is_assoc_ty() =>
         {
             implementor_dups[&path.last()].1
@@ -2551,7 +2550,7 @@ fn render_struct_fields(
                 w.write_str("(")?;
                 if !fields.is_empty()
                     && fields.iter().all(|field| {
-                        matches!(field.kind, clean::StrippedItem(box clean::StructFieldItem(..)))
+                        matches!(field.kind, clean::StrippedItem(clean::StructFieldItem(..)))
                     })
                 {
                     write!(w, "<span class=\"comment\">/* private fields */</span>")?;
@@ -2561,7 +2560,7 @@ fn render_struct_fields(
                             w.write_str(", ")?;
                         }
                         match field.kind {
-                            clean::StrippedItem(box clean::StructFieldItem(..)) => {
+                            clean::StrippedItem(clean::StructFieldItem(..)) => {
                                 write!(w, "_")?;
                             }
                             clean::StructFieldItem(ref ty) => {
diff --git a/src/librustdoc/html/render/sidebar.rs b/src/librustdoc/html/render/sidebar.rs
index 360f8bdf642e2..817e8144bbb4a 100644
--- a/src/librustdoc/html/render/sidebar.rs
+++ b/src/librustdoc/html/render/sidebar.rs
@@ -526,7 +526,7 @@ fn sidebar_deref_methods<'a>(
     debug!("found Deref: {impl_:?}");
     if let Some((target, real_target)) =
         impl_.inner_impl().items.iter().find_map(|item| match item.kind {
-            clean::AssocTypeItem(box ref t, _) => Some(match *t {
+            clean::AssocTypeItem(ref t, _) => Some(match *t {
                 clean::TypeAlias { item_type: Some(ref type_), .. } => (type_, &t.type_),
                 _ => (&t.type_, &t.type_),
             }),
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index 623ad55f6e994..a0140402de428 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -232,7 +232,7 @@ impl FromClean<clean::GenericArg> for GenericArg {
         match arg {
             Lifetime(l) => GenericArg::Lifetime(l.into_json(renderer)),
             Type(t) => GenericArg::Type(t.into_json(renderer)),
-            Const(box c) => GenericArg::Const(c.into_json(renderer)),
+            Const(c) => GenericArg::Const(c.into_json(renderer)),
             Infer => GenericArg::Infer,
         }
     }
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index c8aa197cabe18..2fff3adfa5468 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -5,7 +5,7 @@
 )]
 #![feature(ascii_char)]
 #![feature(ascii_char_variants)]
-#![feature(box_patterns)]
+#![feature(deref_patterns)]
 #![feature(file_buffered)]
 #![feature(formatting_options)]
 #![feature(iter_intersperse)]
diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs
index 762516874c0ae..9d603117ea5ac 100644
--- a/src/librustdoc/passes/collect_trait_impls.rs
+++ b/src/librustdoc/passes/collect_trait_impls.rs
@@ -155,7 +155,7 @@ pub(crate) fn collect_trait_impls(mut krate: Crate, cx: &mut DocContext<'_>) ->
 
     // scan through included items ahead of time to splice in Deref targets to the "valid" sets
     for it in new_items_external.iter().chain(new_items_local.iter()) {
-        if let ImplItem(box Impl { ref for_, ref trait_, ref items, polarity, .. }) = it.kind
+        if let ImplItem(Impl { ref for_, ref trait_, ref items, polarity, .. }) = it.kind
             && trait_.as_ref().map(|t| t.def_id()) == tcx.lang_items().deref_trait()
             && polarity != ty::ImplPolarity::Negative
             && cleaner.keep_impl(for_, true)
@@ -195,7 +195,7 @@ pub(crate) fn collect_trait_impls(mut krate: Crate, cx: &mut DocContext<'_>) ->
 
     // Filter out external items that are not needed
     new_items_external.retain(|it| {
-        if let ImplItem(box Impl { ref for_, ref trait_, ref kind, .. }) = it.kind {
+        if let ImplItem(Impl { ref for_, ref trait_, ref kind, .. }) = it.kind {
             cleaner.keep_impl(
                 for_,
                 trait_.as_ref().map(|t| t.def_id()) == tcx.lang_items().deref_trait(),
diff --git a/src/librustdoc/passes/propagate_stability.rs b/src/librustdoc/passes/propagate_stability.rs
index c8691fd012bf6..6700ca649d7be 100644
--- a/src/librustdoc/passes/propagate_stability.rs
+++ b/src/librustdoc/passes/propagate_stability.rs
@@ -69,7 +69,10 @@ impl DocFolder for StabilityPropagator<'_, '_> {
                     item_stability
                 };
 
-                let (ItemKind::StrippedItem(box kind) | kind) = &item.kind;
+                let kind = match &item.kind {
+                    ItemKind::StrippedItem(kind) => kind,
+                    kind => kind,
+                };
                 match kind {
                     ItemKind::ExternCrateItem { .. }
                     | ItemKind::ImportItem(..)