Remove not needed anymore NonAllocatedGenericArg, some cleanups

Author: aerooneqq

compiler/rustc_ast_lowering/src/delegation.rs

@@ -692,48 +692,42 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let mut segment = segment.clone();
         let mut generated_args_iterator = result.generics.create_args_iterator();
 
-        let new_args = match segment.args {
-            Some(args) if !args.is_empty() => {
+        let new_args = segment
+            .args
+            .filter(|args| !args.is_empty())
+            .map(|args| {
                 let mut new_args = vec![];
 
                 for (idx, arg) in args.args.iter().enumerate() {
                     if infer_indices.contains(&idx) {
-                        let non_alloc_arg = generated_args_iterator
+                        let arg = generated_args_iterator
                             .next(self, |_| arg.hir_id())
                             .expect("there should be one param for each infer");
 
-                        new_args.push(non_alloc_arg.allocate_hir_generic_arg(self.arena));
+                        new_args.push(arg);
                     } else {
                         new_args.push(*arg);
                     }
                 }
 
                 self.arena.alloc_from_iter(new_args.into_iter())
-            }
-            _ => self.arena.alloc_from_iter(
-                generated_args_iterator
-                    .consume_all(self)
-                    .into_iter()
-                    .map(|non_alloc_arg| non_alloc_arg.allocate_hir_generic_arg(self.arena)),
-            ),
-        };
+            })
+            .unwrap_or_else(|| {
+                self.arena.alloc_from_iter(generated_args_iterator.consume_all(self).into_iter())
+            });
 
         // Needed for better error messages (`trait-impl-wrong-args-count.rs` test).
-        segment.args = if new_args.is_empty() {
-            None
-        } else {
-            let new_args = self.arena.alloc(hir::GenericArgs {
+        segment.args = (!new_args.is_empty()).then(|| {
+            &*self.arena.alloc(hir::GenericArgs {
                 args: new_args,
                 constraints: &[],
                 parenthesized: hir::GenericArgsParentheses::No,
                 span_ext: match segment.args {
                     Some(args) => args.span_ext,
                     None => span,
                 },
-            });
-
-            Some(&*new_args)
-        };
+            })
+        });
 
         result.args_segment_id = segment.hir_id;
         result.use_for_sig_inheritance = !result.generics.is_trait_impl();

compiler/rustc_ast_lowering/src/delegation/generics.rs

@@ -89,26 +89,6 @@ pub(super) struct GenericsGenerationResults<'hir> {
     pub(super) self_ty_propagation_kind: Option<hir::DelegationSelfTyPropagationKind>,
 }
 
-#[derive(Debug)]
-pub(super) enum NonAllocatedGenericArg<'hir> {
-    Lifetime(hir::Lifetime),
-    Type(hir::Ty<'hir, hir::AmbigArg>),
-    Const(hir::ConstArg<'hir, hir::AmbigArg>),
-}
-
-impl<'hir> NonAllocatedGenericArg<'hir> {
-    pub(super) fn allocate_hir_generic_arg(
-        self,
-        arena: &'hir hir::Arena<'hir>,
-    ) -> hir::GenericArg<'hir> {
-        match self {
-            NonAllocatedGenericArg::Lifetime(lt) => hir::GenericArg::Lifetime(arena.alloc(lt)),
-            NonAllocatedGenericArg::Type(ty) => hir::GenericArg::Type(arena.alloc(ty)),
-            NonAllocatedGenericArg::Const(c) => hir::GenericArg::Const(arena.alloc(c)),
-        }
-    }
-}
-
 pub(super) struct DelegationGenericArgsIterator<'hir> {
     index: usize = Default::default(),
     params: &'hir [hir::GenericParam<'hir>],
@@ -125,7 +105,7 @@ impl<'hir> DelegationGenericArgsIterator<'hir> {
         &mut self,
         ctx: &mut LoweringContext<'_, 'hir>,
         hir_id_factory: impl FnOnce(&mut LoweringContext<'_, 'hir>) -> HirId,
-    ) -> Option<NonAllocatedGenericArg<'hir>> {
+    ) -> Option<hir::GenericArg<'hir>> {
         let p = loop {
             if self.index >= self.params.len() {
                 return None;
@@ -144,35 +124,35 @@ impl<'hir> DelegationGenericArgsIterator<'hir> {
 
         let hir_id = hir_id_factory(ctx);
 
-        match p.kind {
+        Some(match p.kind {
             hir::GenericParamKind::Lifetime { .. } => {
-                Some(NonAllocatedGenericArg::Lifetime(hir::Lifetime {
+                hir::GenericArg::Lifetime(ctx.arena.alloc(hir::Lifetime {
                     hir_id,
                     ident: p.name.ident(),
                     kind: hir::LifetimeKind::Param(p.def_id),
                     source: hir::LifetimeSource::Path { angle_brackets: hir::AngleBrackets::Full },
                     syntax: hir::LifetimeSyntax::ExplicitBound,
                 }))
             }
-            hir::GenericParamKind::Type { .. } => Some(NonAllocatedGenericArg::Type(hir::Ty {
+            hir::GenericParamKind::Type { .. } => hir::GenericArg::Type(ctx.arena.alloc(hir::Ty {
                 hir_id,
                 span: p.span,
                 kind: hir::TyKind::Path(Self::create_generic_arg_path(ctx, &p)),
             })),
             hir::GenericParamKind::Const { .. } => {
-                Some(NonAllocatedGenericArg::Const(hir::ConstArg {
+                hir::GenericArg::Const(ctx.arena.alloc(hir::ConstArg {
                     hir_id,
                     kind: hir::ConstArgKind::Path(Self::create_generic_arg_path(ctx, &p)),
                     span: p.span,
                 }))
             }
-        }
+        })
     }
 
     pub(super) fn consume_all(
         mut self,
         ctx: &mut LoweringContext<'_, 'hir>,
-    ) -> Vec<NonAllocatedGenericArg<'hir>> {
+    ) -> Vec<hir::GenericArg<'hir>> {
         let mut args = vec![];
         while let Some(arg) = self.next(ctx, |ctx| ctx.next_id()) {
             args.push(arg);