Box Function to reduce the size of ItemKind

This brings the sizes down to

```
[src/librustdoc/lib.rs:102] std::mem::size_of::<Item>() = 520
[src/librustdoc/lib.rs:102] std::mem::size_of::<ItemKind>() = 248
```

from

```
[src/librustdoc/lib.rs:102] std::mem::size_of::<Item>() = 608
[src/librustdoc/lib.rs:102] std::mem::size_of::<ItemKind>() = 336
```

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);

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,7 +1116,7 @@ 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);
@@ -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()),