Remove box from ConstItem and StaticItem ty

Author: camsteffen

compiler/rustc_ast/src/ast.rs

@@ -3851,7 +3851,7 @@ pub struct DelegationMac {
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct StaticItem {
     pub ident: Ident,
-    pub ty: Box<Ty>,
+    pub ty: Ty,
     pub safety: Safety,
     pub mutability: Mutability,
     pub expr: Option<Box<Expr>>,
@@ -3863,7 +3863,7 @@ pub struct ConstItem {
     pub defaultness: Defaultness,
     pub ident: Ident,
     pub generics: Generics,
-    pub ty: Box<Ty>,
+    pub ty: Ty,
     pub rhs_kind: ConstItemRhsKind,
     pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
 }

compiler/rustc_builtin_macros/src/proc_macro_harness.rs

@@ -365,7 +365,7 @@ fn mk_decls(cx: &mut ExtCtxt<'_>, macros: &[ProcMacro]) -> Box<ast::Item> {
     let mut decls_static = cx.item_static(
         span,
         Ident::new(sym::_DECLS, span),
-        Box::new(cx.ty_ref(
+        cx.ty_ref(
             span,
             Box::new(cx.ty(
                 span,
@@ -375,7 +375,7 @@ fn mk_decls(cx: &mut ExtCtxt<'_>, macros: &[ProcMacro]) -> Box<ast::Item> {
             )),
             None,
             ast::Mutability::Not,
-        )),
+        ),
         ast::Mutability::Not,
         cx.expr_array_ref(span, decls),
     );

compiler/rustc_builtin_macros/src/test.rs

@@ -286,7 +286,7 @@ pub(crate) fn expand_test_or_bench(
                     defaultness: ast::Defaultness::Implicit,
                     ident: Ident::new(fn_.ident.name, sp),
                     generics: ast::Generics::default(),
-                    ty: Box::new(cx.ty(sp, ast::TyKind::Path(None, test_path("TestDescAndFn")))),
+                    ty: cx.ty(sp, ast::TyKind::Path(None, test_path("TestDescAndFn"))),
                     define_opaque: None,
                     // test::TestDescAndFn {
                     rhs_kind: ast::ConstItemRhsKind::new_body(

compiler/rustc_expand/src/build.rs

@@ -701,7 +701,7 @@ impl<'a> ExtCtxt<'a> {
         &self,
         span: Span,
         ident: Ident,
-        ty: Box<ast::Ty>,
+        ty: ast::Ty,
         mutability: ast::Mutability,
         expr: Box<ast::Expr>,
     ) -> Box<ast::Item> {
@@ -739,7 +739,7 @@ impl<'a> ExtCtxt<'a> {
                     ident,
                     // FIXME(generic_const_items): Pass the generics as a parameter.
                     generics: ast::Generics::default(),
-                    ty: Box::new(ty),
+                    ty,
                     rhs_kind,
                     define_opaque: None,
                 }

compiler/rustc_parse/src/parser/item.rs

@@ -1530,7 +1530,7 @@ impl<'a> Parser<'a> {
         // Parse the type of a static item. That is, the `":" $ty` fragment.
         // FIXME: This could maybe benefit from `.may_recover()`?
         let ty = match (self.eat(exp!(Colon)), self.check(exp!(Eq)) | self.check(exp!(Semi))) {
-            (true, false) => Box::new(self.parse_ty()?),
+            (true, false) => self.parse_ty()?,
             // If there wasn't a `:` or the colon was followed by a `=` or `;`, recover a missing
             // type.
             (colon, _) => self.recover_missing_global_item_type(colon, Some(mutability)),
@@ -1555,7 +1555,7 @@ impl<'a> Parser<'a> {
     fn parse_const_item(
         &mut self,
         const_arg: bool,
-    ) -> PResult<'a, (Ident, Generics, Box<Ty>, ConstItemRhsKind)> {
+    ) -> PResult<'a, (Ident, Generics, Ty, ConstItemRhsKind)> {
         let ident = self.parse_ident_or_underscore()?;
 
         let mut generics = self.parse_generics()?;
@@ -1572,7 +1572,7 @@ impl<'a> Parser<'a> {
             self.eat(exp!(Colon)),
             self.check(exp!(Eq)) | self.check(exp!(Semi)) | self.check_keyword(exp!(Where)),
         ) {
-            (true, false) => Box::new(self.parse_ty()?),
+            (true, false) => self.parse_ty()?,
             // If there wasn't a `:` or the colon was followed by a `=`, `;` or `where`, recover a missing type.
             (colon, _) => self.recover_missing_global_item_type(colon, None),
         };
@@ -1657,7 +1657,7 @@ impl<'a> Parser<'a> {
         &mut self,
         colon_present: bool,
         m: Option<Mutability>,
-    ) -> Box<Ty> {
+    ) -> Ty {
         // Construct the error and stash it away with the hope
         // that typeck will later enrich the error with a type.
         let kind = match m {
@@ -1677,7 +1677,7 @@ impl<'a> Parser<'a> {
 
         // The user intended that the type be inferred,
         // so treat this as if the user wrote e.g. `const A: _ = expr;`.
-        Box::new(Ty { kind: TyKind::Infer, span, id: ast::DUMMY_NODE_ID, tokens: None })
+        Ty { kind: TyKind::Infer, span, id: ast::DUMMY_NODE_ID, tokens: None }
     }
 
     /// Parses an enum declaration.