Box Mod and ForeignMod

bugadani · bugadani · commit bc438da1ac43 · 2021-02-02T22:58:05.000+01:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -2725,11 +2725,11 @@ pub enum ItemKind {
     /// A module declaration (`mod`).
     ///
     /// E.g., `mod foo;` or `mod foo { .. }`.
-    Mod(Mod),
+    Mod(Box<Mod>),
     /// An external module (`extern`).
     ///
     /// E.g., `extern {}` or `extern "C" {}`.
-    ForeignMod(ForeignMod),
+    ForeignMod(Box<ForeignMod>),
     /// Module-level inline assembly (from `global_asm!()`).
     GlobalAsm(Box<GlobalAsm>),
     /// A type alias (`type`).
@@ -2770,7 +2770,7 @@ pub enum ItemKind {
 }
 
 #[cfg(target_arch = "x86_64")]
-rustc_data_structures::static_assert_size!(ItemKind, 72);
+rustc_data_structures::static_assert_size!(ItemKind, 24);
 
 impl ItemKind {
     pub fn article(&self) -> &str {
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -1016,7 +1016,7 @@ pub fn noop_visit_crate<T: MutVisitor>(krate: &mut Crate, vis: &mut T) {
             id: DUMMY_NODE_ID,
             vis: item_vis,
             span,
-            kind: ItemKind::Mod(module),
+            kind: ItemKind::Mod(box module),
             tokens: None,
         });
         let items = vis.flat_map_item(item);
@@ -1028,7 +1028,7 @@ pub fn noop_visit_crate<T: MutVisitor>(krate: &mut Crate, vis: &mut T) {
         } else if len == 1 {
             let Item { attrs, span, kind, .. } = items.into_iter().next().unwrap().into_inner();
             match kind {
-                ItemKind::Mod(module) => Crate { module, attrs, span, proc_macros },
+                ItemKind::Mod(box module) => Crate { module, attrs, span, proc_macros },
                 _ => panic!("visitor converted a module to not a module"),
             }
         } else {
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -1006,7 +1006,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                     self.error_item_without_body(item.span, "function", msg, " { <body> }");
                 }
             }
-            ItemKind::ForeignMod(ForeignMod { unsafety, .. }) => {
+            ItemKind::ForeignMod(box ForeignMod { unsafety, .. }) => {
                 let old_item = mem::replace(&mut self.extern_mod, Some(item));
                 self.invalid_visibility(
                     &item.vis,
@@ -1054,7 +1054,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 walk_list!(self, visit_attribute, &item.attrs);
                 return;
             }
-            ItemKind::Mod(Mod { inline, unsafety, .. }) => {
+            ItemKind::Mod(box Mod { inline, unsafety, .. }) => {
                 if let Unsafe::Yes(span) = unsafety {
                     self.err_handler().span_err(span, "module cannot be declared unsafe");
                 }
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
@@ -376,7 +376,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
         let krate_item = AstFragment::Items(smallvec![P(ast::Item {
             attrs: krate.attrs,
             span: krate.span,
-            kind: ast::ItemKind::Mod(krate.module),
+            kind: ast::ItemKind::Mod(box krate.module),
             ident: Ident::invalid(),
             id: ast::DUMMY_NODE_ID,
             vis: ast::Visibility {
@@ -388,7 +388,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
         })]);
 
         match self.fully_expand_fragment(krate_item).make_items().pop().map(P::into_inner) {
-            Some(ast::Item { attrs, kind: ast::ItemKind::Mod(module), .. }) => {
+            Some(ast::Item { attrs, kind: ast::ItemKind::Mod(box module), .. }) => {
                 krate.attrs = attrs;
                 krate.module = module;
             }
@@ -1379,7 +1379,9 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
                     _ => unreachable!(),
                 })
             }
-            ast::ItemKind::Mod(ref mut old_mod @ ast::Mod { .. }) if ident != Ident::invalid() => {
+            ast::ItemKind::Mod(ref mut old_mod @ box ast::Mod { .. })
+                if ident != Ident::invalid() =>
+            {
                 let sess = &self.cx.sess.parse_sess;
                 let orig_ownership = self.cx.current_expansion.directory_ownership;
                 let mut module = (*self.cx.current_expansion.module).clone();
@@ -1412,7 +1414,7 @@ impl<'a, 'b> MutVisitor for InvocationCollector<'a, 'b> {
                         extern_mod_loaded(&krate, ident);
                     }
 
-                    *old_mod = krate.module;
+                    *old_mod = box krate.module;
                     item.attrs = krate.attrs;
                     // File can have inline attributes, e.g., `#![cfg(...)]` & co. => Reconfigure.
                     item = match self.configure(item) {
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -46,7 +46,7 @@ impl<'a> Parser<'a> {
             self.parse_mod(&token::CloseDelim(token::Brace), unsafety)?
         };
         attrs.append(&mut inner_attrs);
-        Ok((id, ItemKind::Mod(module)))
+        Ok((id, ItemKind::Mod(box module)))
     }
 
     /// Parses the contents of a module (inner attributes followed by module items).
@@ -919,7 +919,7 @@ impl<'a> Parser<'a> {
         let abi = self.parse_abi(); // ABI?
         let items = self.parse_item_list(attrs, |p| p.parse_foreign_item())?;
         let module = ast::ForeignMod { unsafety, abi, items };
-        Ok((Ident::invalid(), ItemKind::ForeignMod(module)))
+        Ok((Ident::invalid(), ItemKind::ForeignMod(box module)))
     }
 
     /// Parses a foreign item (one in an `extern { ... }` block).

Original file line number	Diff line number	Diff line change
`@@ -1006,7 +1006,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`1006`	`1006`	`self.error_item_without_body(item.span, "function", msg, " { <body> }");`
`1007`	`1007`	`}`
`1008`	`1008`	`}`
`1009`		`- ItemKind::ForeignMod(ForeignMod { unsafety, .. }) => {`
	`1009`	`+ ItemKind::ForeignMod(box ForeignMod { unsafety, .. }) => {`
`1010`	`1010`	`let old_item = mem::replace(&mut self.extern_mod, Some(item));`
`1011`	`1011`	`self.invalid_visibility(`
`1012`	`1012`	`&item.vis,`
`@@ -1054,7 +1054,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {`
`1054`	`1054`	`walk_list!(self, visit_attribute, &item.attrs);`
`1055`	`1055`	`return;`
`1056`	`1056`	`}`
`1057`		`- ItemKind::Mod(Mod { inline, unsafety, .. }) => {`
	`1057`	`+ ItemKind::Mod(box Mod { inline, unsafety, .. }) => {`
`1058`	`1058`	`if let Unsafe::Yes(span) = unsafety {`
`1059`	`1059`	`self.err_handler().span_err(span, "module cannot be declared unsafe");`
`1060`	`1060`	`}`