Box the UseTree in ItemKind::UseTree.

Author: nnethercote

compiler/rustc_ast/src/ast.rs

@@ -2817,7 +2817,7 @@ pub enum ItemKind {
     /// A use declaration item (`use`).
     ///
     /// E.g., `use foo;`, `use foo::bar;` or `use foo::bar as FooBar;`.
-    Use(UseTree),
+    Use(P<UseTree>),
     /// A static item (`static`).
     ///
     /// E.g., `static FOO: i32 = 42;` or `static FOO: &'static str = "bar";`.
@@ -3043,8 +3043,8 @@ mod size_asserts {
     static_assert_size!(GenericBound, 88);
     static_assert_size!(Generics, 72);
     static_assert_size!(Impl, 200);
-    static_assert_size!(Item, 176);
-    static_assert_size!(ItemKind, 88);
+    static_assert_size!(Item, 160);
+    static_assert_size!(ItemKind, 72);
     static_assert_size!(Lit, 48);
     static_assert_size!(Pat, 120);
     static_assert_size!(Path, 40);

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -120,14 +120,14 @@ impl<'cx, 'a> Context<'cx, 'a> {
                     Ident::new(sym::allow, self.span),
                     vec![attr::mk_nested_word_item(Ident::new(sym::unused_imports, self.span))],
                 ))],
-                ItemKind::Use(UseTree {
+                ItemKind::Use(P(UseTree {
                     prefix: self.cx.path(self.span, self.cx.std_path(&[sym::asserting])),
                     kind: UseTreeKind::Nested(vec![
                         nested_tree(self, sym::TryCaptureGeneric),
                         nested_tree(self, sym::TryCapturePrintable),
                     ]),
                     span: self.span,
-                }),
+                })),
             ),
         )
     }

compiler/rustc_builtin_macros/src/standard_library_imports.rs

@@ -1,4 +1,5 @@
 use rustc_ast as ast;
+use rustc_ast::ptr::P;
 use rustc_expand::base::{ExtCtxt, ResolverExpand};
 use rustc_expand::expand::ExpansionConfig;
 use rustc_session::Session;
@@ -79,11 +80,11 @@ pub fn inject(
         span,
         Ident::empty(),
         vec![cx.attribute(cx.meta_word(span, sym::prelude_import))],
-        ast::ItemKind::Use(ast::UseTree {
+        ast::ItemKind::Use(P(ast::UseTree {
             prefix: cx.path(span, import_path),
             kind: ast::UseTreeKind::Glob,
             span,
-        }),
+        })),
     );
 
     krate.items.insert(0, use_item);

compiler/rustc_parse/src/parser/item.rs

@@ -328,7 +328,7 @@ impl<'a> Parser<'a> {
             }
             return Err(e);
         }
-        Ok((Ident::empty(), ItemKind::Use(tree)))
+        Ok((Ident::empty(), ItemKind::Use(P(tree))))
     }
 
     /// When parsing a statement, would the start of a path be an item?