Box Function to reduce the size of ItemKind

Author: jyn514

src/librustdoc/clean/inline.rs

@@ -62,7 +62,7 @@ crate fn try_inline(
         }
         Res::Def(DefKind::Fn, did) => {
             record_extern_fqn(cx, did, clean::TypeKind::Function);
-            clean::FunctionItem(build_external_function(cx, did))
+            clean::FunctionItem(box build_external_function(cx, did))
         }
         Res::Def(DefKind::Struct, did) => {
             record_extern_fqn(cx, did, clean::TypeKind::Struct);
@@ -77,7 +77,7 @@ crate fn try_inline(
         Res::Def(DefKind::TyAlias, did) => {
             record_extern_fqn(cx, did, clean::TypeKind::Typedef);
             ret.extend(build_impls(cx, Some(parent_module), did, attrs));
-            clean::TypedefItem(build_type_alias(cx, did), false)
+            clean::TypedefItem(box build_type_alias(cx, did), false)
         }
         Res::Def(DefKind::Enum, did) => {
             record_extern_fqn(cx, did, clean::TypeKind::Enum);

src/librustdoc/clean/mod.rs

@@ -919,7 +919,7 @@ fn clean_fn_or_proc_macro(
                 } else {
                     hir::Constness::NotConst
                 };
-            FunctionItem(func)
+            FunctionItem(box func)
         }
     }
 }
@@ -1076,7 +1076,7 @@ impl Clean<Item> for hir::TraitItem<'_> {
                     {
                         m.header.constness = hir::Constness::NotConst;
                     }
-                    MethodItem(m, None)
+                    MethodItem(box m, None)
                 }
                 hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Required(ref names)) => {
                     let (generics, decl) = enter_impl_trait(cx, || {
@@ -1090,7 +1090,7 @@ impl Clean<Item> for hir::TraitItem<'_> {
                     {
                         t.header.constness = hir::Constness::NotConst;
                     }
-                    TyMethodItem(t)
+                    TyMethodItem(box t)
                 }
                 hir::TraitItemKind::Type(ref bounds, ref default) => {
                     AssocTypeItem(bounds.clean(cx), default.clean(cx))
@@ -1116,12 +1116,12 @@ impl Clean<Item> for hir::ImplItem<'_> {
                     {
                         m.header.constness = hir::Constness::NotConst;
                     }
-                    MethodItem(m, Some(self.defaultness))
+                    MethodItem(box m, Some(self.defaultness))
                 }
                 hir::ImplItemKind::TyAlias(ref ty) => {
                     let type_ = ty.clean(cx);
                     let item_type = type_.def_id().and_then(|did| inline::build_ty(cx, did));
-                    TypedefItem(Typedef { type_, generics: Generics::default(), item_type }, true)
+                    TypedefItem(box Typedef { type_, generics: Generics::default(), item_type }, true)
                 }
             };
             Item::from_def_id_and_parts(local_did, Some(self.ident.name.clean(cx)), inner, cx)
@@ -1185,7 +1185,7 @@ impl Clean<Item> for ty::AssocItem {
                         ty::TraitContainer(_) => None,
                     };
                     MethodItem(
-                        Function {
+                        box Function {
                             generics,
                             decl,
                             header: hir::FnHeader {
@@ -1200,7 +1200,7 @@ impl Clean<Item> for ty::AssocItem {
                         defaultness,
                     )
                 } else {
-                    TyMethodItem(Function {
+                    TyMethodItem(box Function {
                         generics,
                         decl,
                         header: hir::FnHeader {
@@ -2263,7 +2263,7 @@ impl Clean<Item> for (&hir::ForeignItem<'_>, Option<Symbol>) {
                         (generics.clean(cx), (&**decl, &names[..]).clean(cx))
                     });
                     let (all_types, ret_types) = get_all_types(&generics, &decl, cx);
-                    ForeignFunctionItem(Function {
+                    ForeignFunctionItem(box Function {
                         decl,
                         generics,
                         header: hir::FnHeader {

src/librustdoc/clean/types.rs

@@ -305,7 +305,7 @@ crate enum ItemKind {
     StructItem(Struct),
     UnionItem(Union),
     EnumItem(Enum),
-    FunctionItem(Function),
+    FunctionItem(Box<Function>),
     ModuleItem(Module),
     TypedefItem(Typedef, bool /* is associated type */),
     OpaqueTyItem(OpaqueTy),
@@ -318,13 +318,13 @@ crate enum ItemKind {
     ImplItem(Box<Impl>),
     /// A method signature only. Used for required methods in traits (ie,
     /// non-default-methods).
-    TyMethodItem(Function),
+    TyMethodItem(Box<Function>),
     /// A method with a body.
-    MethodItem(Function, Option<hir::Defaultness>),
+    MethodItem(Box<Function>, Option<hir::Defaultness>),
     StructFieldItem(Type),
     VariantItem(Variant),
     /// `fn`s from an extern block
-    ForeignFunctionItem(Function),
+    ForeignFunctionItem(Box<Function>),
     /// `static`s from an extern block
     ForeignStaticItem(Static),
     /// `type`s from an extern block

src/librustdoc/json/conversions.rs

@@ -169,12 +169,12 @@ impl From<clean::ItemKind> for ItemEnum {
             StructFieldItem(f) => ItemEnum::StructFieldItem(f.into()),
             EnumItem(e) => ItemEnum::EnumItem(e.into()),
             VariantItem(v) => ItemEnum::VariantItem(v.into()),
-            FunctionItem(f) => ItemEnum::FunctionItem(f.into()),
-            ForeignFunctionItem(f) => ItemEnum::FunctionItem(f.into()),
+            FunctionItem(box f) => ItemEnum::FunctionItem(f.into()),
+            ForeignFunctionItem(box f) => ItemEnum::FunctionItem(f.into()),
             TraitItem(t) => ItemEnum::TraitItem(t.into()),
             TraitAliasItem(t) => ItemEnum::TraitAliasItem(t.into()),
-            MethodItem(m, _) => ItemEnum::MethodItem(m.into()),
-            TyMethodItem(m) => ItemEnum::MethodItem(m.into()),
+            MethodItem(box m, _) => ItemEnum::MethodItem(m.into()),
+            TyMethodItem(box m) => ItemEnum::MethodItem(m.into()),
             ImplItem(box i) => ItemEnum::ImplItem(i.into()),
             StaticItem(s) => ItemEnum::StaticItem(s.into()),
             ForeignStaticItem(s) => ItemEnum::StaticItem(s.into()),