Propagate ImplOfTrait to hir

Author: camsteffen

compiler/rustc_ast_lowering/src/item.rs

@@ -361,71 +361,69 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 // lifetime to be added, but rather a reference to a
                 // parent lifetime.
                 let itctx = ImplTraitContext::Universal;
-                let (generics, (trait_ref, lowered_ty)) =
+                let (generics, (of_trait, lowered_ty)) =
                     self.lower_generics(ast_generics, id, itctx, |this| {
-                        let modifiers = TraitBoundModifiers {
-                            constness: BoundConstness::Never,
-                            asyncness: BoundAsyncness::Normal,
-                            // we don't use this in bound lowering
-                            polarity: BoundPolarity::Positive,
-                        };
-
-                        let trait_ref = of_trait.as_ref().map(|of_trait| {
-                            this.lower_trait_ref(
+                        let of_trait = of_trait.as_deref().map(|of_trait| {
+                            let ImplOfTrait {
+                                constness,
+                                safety,
+                                polarity,
+                                defaultness,
+                                ref trait_ref,
+                            } = *of_trait;
+                            let constness = this.lower_constness(constness);
+                            let safety = this.lower_safety(safety, hir::Safety::Safe);
+                            let polarity = match polarity {
+                                ImplPolarity::Positive => ImplPolarity::Positive,
+                                ImplPolarity::Negative(s) => {
+                                    ImplPolarity::Negative(this.lower_span(s))
+                                }
+                            };
+                            // `defaultness.has_value()` is never called for an `impl`, always `true` in order
+                            // to not cause an assertion failure inside the `lower_defaultness` function.
+                            let has_val = true;
+                            let (defaultness, defaultness_span) =
+                                this.lower_defaultness(defaultness, has_val);
+                            let modifiers = TraitBoundModifiers {
+                                constness: BoundConstness::Never,
+                                asyncness: BoundAsyncness::Normal,
+                                // we don't use this in bound lowering
+                                polarity: BoundPolarity::Positive,
+                            };
+                            let trait_ref = this.lower_trait_ref(
                                 modifiers,
-                                &of_trait.trait_ref,
+                                trait_ref,
                                 ImplTraitContext::Disallowed(ImplTraitPosition::Trait),
-                            )
+                            );
+
+                            &*this.arena.alloc(hir::ImplOfTrait {
+                                constness,
+                                safety,
+                                polarity,
+                                defaultness,
+                                defaultness_span,
+                                trait_ref,
+                            })
                         });
 
                         let lowered_ty = this.lower_ty(
                             ty,
                             ImplTraitContext::Disallowed(ImplTraitPosition::ImplSelf),
                         );
 
-                        (trait_ref, lowered_ty)
+                        (of_trait, lowered_ty)
                     });
 
                 let new_impl_items = self
                     .arena
                     .alloc_from_iter(impl_items.iter().map(|item| self.lower_impl_item_ref(item)));
 
-                // `defaultness.has_value()` is never called for an `impl`, always `true` in order
-                // to not cause an assertion failure inside the `lower_defaultness` function.
-                let has_val = true;
-                let (constness, safety, polarity, defaultness, defaultness_span) = match of_trait {
-                    Some(of_trait) => {
-                        let ImplOfTrait { constness, safety, polarity, defaultness, trait_ref: _ } =
-                            **of_trait;
-                        let constness = self.lower_constness(constness);
-                        let safety = self.lower_safety(safety, hir::Safety::Safe);
-                        let polarity = match polarity {
-                            ImplPolarity::Positive => ImplPolarity::Positive,
-                            ImplPolarity::Negative(s) => ImplPolarity::Negative(self.lower_span(s)),
-                        };
-                        let (defaultness, defaultness_span) =
-                            self.lower_defaultness(defaultness, has_val);
-                        (constness, safety, polarity, defaultness, defaultness_span)
-                    }
-                    None => (
-                        hir::Constness::NotConst,
-                        hir::Safety::Safe,
-                        ImplPolarity::Positive,
-                        hir::Defaultness::Final,
-                        None,
-                    ),
-                };
-                hir::ItemKind::Impl(self.arena.alloc(hir::Impl {
-                    constness,
-                    safety,
-                    polarity,
-                    defaultness,
-                    defaultness_span,
+                hir::ItemKind::Impl(hir::Impl {
                     generics,
-                    of_trait: trait_ref,
+                    of_trait,
                     self_ty: lowered_ty,
                     items: new_impl_items,
-                }))
+                })
             }
             ItemKind::Trait(box Trait {
                 constness,

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -324,27 +324,26 @@ impl<'a> State<'a> {
                     }
                 };
 
-                match of_trait {
-                    None => impl_generics(self),
-                    Some(box of_trait) => {
-                        let ast::ImplOfTrait {
-                            defaultness,
-                            safety,
-                            constness,
-                            polarity,
-                            ref trait_ref,
-                        } = *of_trait;
-                        self.print_defaultness(defaultness);
-                        self.print_safety(safety);
-                        impl_generics(self);
-                        self.print_constness(constness);
-                        if let ast::ImplPolarity::Negative(_) = polarity {
-                            self.word("!");
-                        }
-                        self.print_trait_ref(trait_ref);
-                        self.space();
-                        self.word_space("for");
+                if let Some(box of_trait) = of_trait {
+                    let ast::ImplOfTrait {
+                        defaultness,
+                        safety,
+                        constness,
+                        polarity,
+                        ref trait_ref,
+                    } = *of_trait;
+                    self.print_defaultness(defaultness);
+                    self.print_safety(safety);
+                    impl_generics(self);
+                    self.print_constness(constness);
+                    if let ast::ImplPolarity::Negative(_) = polarity {
+                        self.word("!");
                     }
+                    self.print_trait_ref(trait_ref);
+                    self.space();
+                    self.word_space("for");
+                } else {
+                    impl_generics(self);
                 }
 
                 self.print_type(self_ty);

compiler/rustc_hir/src/hir.rs

@@ -4178,7 +4178,7 @@ impl<'hir> Item<'hir> {
         expect_trait_alias, (Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
             ItemKind::TraitAlias(ident, generics, bounds), (*ident, generics, bounds);
 
-        expect_impl, &'hir Impl<'hir>, ItemKind::Impl(imp), imp;
+        expect_impl, &Impl<'hir>, ItemKind::Impl(imp), imp;
     }
 }
 
@@ -4356,7 +4356,7 @@ pub enum ItemKind<'hir> {
     TraitAlias(Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
 
     /// An implementation, e.g., `impl<A> Trait for Foo { .. }`.
-    Impl(&'hir Impl<'hir>),
+    Impl(Impl<'hir>),
 }
 
 /// Represents an impl block declaration.
@@ -4365,20 +4365,22 @@ pub enum ItemKind<'hir> {
 /// Refer to [`ImplItem`] for an associated item within an impl block.
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct Impl<'hir> {
+    pub generics: &'hir Generics<'hir>,
+    pub of_trait: Option<&'hir ImplOfTrait<'hir>>,
+    pub self_ty: &'hir Ty<'hir>,
+    pub items: &'hir [ImplItemId],
+}
+
+#[derive(Debug, Clone, Copy, HashStable_Generic)]
+pub struct ImplOfTrait<'hir> {
     pub constness: Constness,
     pub safety: Safety,
     pub polarity: ImplPolarity,
     pub defaultness: Defaultness,
     // We do not put a `Span` in `Defaultness` because it breaks foreign crate metadata
     // decoding as `Span`s cannot be decoded when a `Session` is not available.
     pub defaultness_span: Option<Span>,
-    pub generics: &'hir Generics<'hir>,
-
-    /// The trait being implemented, if any.
-    pub of_trait: Option<TraitRef<'hir>>,
-
-    pub self_ty: &'hir Ty<'hir>,
-    pub items: &'hir [ImplItemId],
+    pub trait_ref: TraitRef<'hir>,
 }
 
 impl ItemKind<'_> {
@@ -4740,8 +4742,8 @@ impl<'hir> Node<'hir> {
     /// Get a `hir::Impl` if the node is an impl block for the given `trait_def_id`.
     pub fn impl_block_of_trait(self, trait_def_id: DefId) -> Option<&'hir Impl<'hir>> {
         if let Node::Item(Item { kind: ItemKind::Impl(impl_block), .. }) = self
-            && let Some(trait_ref) = impl_block.of_trait
-            && let Some(trait_id) = trait_ref.trait_def_id()
+            && let Some(of_trait) = impl_block.of_trait
+            && let Some(trait_id) = of_trait.trait_ref.trait_def_id()
             && trait_id == trait_def_id
         {
             Some(impl_block)
@@ -4936,9 +4938,10 @@ mod size_asserts {
     static_assert_size!(GenericArg<'_>, 16);
     static_assert_size!(GenericBound<'_>, 64);
     static_assert_size!(Generics<'_>, 56);
-    static_assert_size!(Impl<'_>, 80);
+    static_assert_size!(Impl<'_>, 40);
     static_assert_size!(ImplItem<'_>, 96);
     static_assert_size!(ImplItemKind<'_>, 40);
+    static_assert_size!(ImplOfTrait<'_>, 48);
     static_assert_size!(Item<'_>, 88);
     static_assert_size!(ItemKind<'_>, 64);
     static_assert_size!(LetStmt<'_>, 72);

compiler/rustc_hir/src/intravisit.rs

@@ -596,21 +596,13 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
             try_visit!(visitor.visit_generics(generics));
             try_visit!(visitor.visit_enum_def(enum_definition));
         }
-        ItemKind::Impl(Impl {
-            constness: _,
-            safety: _,
-            defaultness: _,
-            polarity: _,
-            defaultness_span: _,
-            generics,
-            of_trait,
-            self_ty,
-            items,
-        }) => {
+        ItemKind::Impl(Impl { generics, of_trait, self_ty, items }) => {
             try_visit!(visitor.visit_generics(generics));
-            visit_opt!(visitor, visit_trait_ref, of_trait);
+            if let Some(of_trait) = of_trait {
+                try_visit!(visitor.visit_trait_ref(&of_trait.trait_ref));
+            }
             try_visit!(visitor.visit_ty_unambig(self_ty));
-            walk_list!(visitor, visit_impl_item_ref, *items);
+            walk_list!(visitor, visit_impl_item_ref, items);
         }
         ItemKind::Struct(ident, ref generics, ref struct_definition)
         | ItemKind::Union(ident, ref generics, ref struct_definition) => {