rename the lower_anon_const_to_const_arg and

`lower_anon_const_to_const_arg_direct` to
`lower_anon_const_to_const_arg_and_alloc` and
`lower_anon_const_to_const_arg`

Author: reddevilmidzy

compiler/rustc_ast_lowering/src/lib.rs

@@ -1126,7 +1126,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             AssocItemConstraintKind::Equality { term } => {
                 let term = match term {
                     Term::Ty(ty) => self.lower_ty_alloc(ty, itctx).into(),
-                    Term::Const(c) => self.lower_anon_const_to_const_arg(c).into(),
+                    Term::Const(c) => self.lower_anon_const_to_const_arg_alloc(c).into(),
                 };
                 hir::AssocItemConstraintKind::Equality { term }
             }
@@ -1252,9 +1252,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 }
                 GenericArg::Type(self.lower_ty_alloc(ty, itctx).try_as_ambig_ty().unwrap())
             }
-            ast::GenericArg::Const(ct) => {
-                GenericArg::Const(self.lower_anon_const_to_const_arg(ct).try_as_ambig_ct().unwrap())
-            }
+            ast::GenericArg::Const(ct) => GenericArg::Const(
+                self.lower_anon_const_to_const_arg_alloc(ct).try_as_ambig_ct().unwrap(),
+            ),
         }
     }
 
@@ -2066,7 +2066,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             false
                         }
                     })
-                    .map(|def| self.lower_anon_const_to_const_arg(def));
+                    .map(|def| self.lower_anon_const_to_const_arg_alloc(def));
 
                 (
                     hir::ParamName::Plain(self.lower_ident(param.ident)),
@@ -2288,7 +2288,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 let ct_kind = hir::ConstArgKind::Infer(self.lower_span(c.value.span), ());
                 self.arena.alloc(hir::ConstArg { hir_id: self.lower_node_id(c.id), kind: ct_kind })
             }
-            _ => self.lower_anon_const_to_const_arg(c),
+            _ => self.lower_anon_const_to_const_arg_alloc(c),
         }
     }
 
@@ -2367,7 +2367,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     ) -> hir::ConstItemRhs<'hir> {
         match rhs {
             Some(ConstItemRhs::TypeConst(anon)) => {
-                hir::ConstItemRhs::TypeConst(self.lower_anon_const_to_const_arg(anon))
+                hir::ConstItemRhs::TypeConst(self.lower_anon_const_to_const_arg_alloc(anon))
             }
             None if attr::contains_name(attrs, sym::type_const) => {
                 let const_arg = ConstArg {
@@ -2438,7 +2438,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         let def_kind = self.tcx.def_kind(def_id);
                         assert_eq!(DefKind::AnonConst, def_kind);
 
-                        self.lower_anon_const_to_const_arg_direct(anon_const)
+                        self.lower_anon_const_to_const_arg(anon_const)
                     } else {
                         self.lower_expr_to_const_arg_direct(&f.expr)
                     };
@@ -2476,12 +2476,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     /// See [`hir::ConstArg`] for when to use this function vs
     /// [`Self::lower_anon_const_to_anon_const`].
-    fn lower_anon_const_to_const_arg(&mut self, anon: &AnonConst) -> &'hir hir::ConstArg<'hir> {
-        self.arena.alloc(self.lower_anon_const_to_const_arg_direct(anon))
+    fn lower_anon_const_to_const_arg_alloc(
+        &mut self,
+        anon: &AnonConst,
+    ) -> &'hir hir::ConstArg<'hir> {
+        self.arena.alloc(self.lower_anon_const_to_const_arg(anon))
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn lower_anon_const_to_const_arg_direct(&mut self, anon: &AnonConst) -> hir::ConstArg<'hir> {
+    fn lower_anon_const_to_const_arg(&mut self, anon: &AnonConst) -> hir::ConstArg<'hir> {
         let tcx = self.tcx;
 
         // We cannot change parsing depending on feature gates available,

compiler/rustc_ast_lowering/src/pat.rs

@@ -441,36 +441,37 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn lower_ty_pat_mut(&mut self, pattern: &TyPat, base_type: Span) -> hir::TyPat<'hir> {
         // loop here to avoid recursion
         let pat_hir_id = self.lower_node_id(pattern.id);
-        let node = match &pattern.kind {
-            TyPatKind::Range(e1, e2, Spanned { node: end, span }) => hir::TyPatKind::Range(
-                e1.as_deref().map(|e| self.lower_anon_const_to_const_arg(e)).unwrap_or_else(|| {
-                    self.lower_ty_pat_range_end(
-                        hir::LangItem::RangeMin,
-                        span.shrink_to_lo(),
-                        base_type,
-                    )
-                }),
-                e2.as_deref()
-                    .map(|e| match end {
-                        RangeEnd::Included(..) => self.lower_anon_const_to_const_arg(e),
-                        RangeEnd::Excluded => self.lower_excluded_range_end(e),
-                    })
-                    .unwrap_or_else(|| {
-                        self.lower_ty_pat_range_end(
-                            hir::LangItem::RangeMax,
-                            span.shrink_to_hi(),
-                            base_type,
-                        )
-                    }),
-            ),
-            TyPatKind::NotNull => hir::TyPatKind::NotNull,
-            TyPatKind::Or(variants) => {
-                hir::TyPatKind::Or(self.arena.alloc_from_iter(
+        let node =
+            match &pattern.kind {
+                TyPatKind::Range(e1, e2, Spanned { node: end, span }) => hir::TyPatKind::Range(
+                    e1.as_deref()
+                        .map(|e| self.lower_anon_const_to_const_arg_alloc(e))
+                        .unwrap_or_else(|| {
+                            self.lower_ty_pat_range_end(
+                                hir::LangItem::RangeMin,
+                                span.shrink_to_lo(),
+                                base_type,
+                            )
+                        }),
+                    e2.as_deref()
+                        .map(|e| match end {
+                            RangeEnd::Included(..) => self.lower_anon_const_to_const_arg_alloc(e),
+                            RangeEnd::Excluded => self.lower_excluded_range_end(e),
+                        })
+                        .unwrap_or_else(|| {
+                            self.lower_ty_pat_range_end(
+                                hir::LangItem::RangeMax,
+                                span.shrink_to_hi(),
+                                base_type,
+                            )
+                        }),
+                ),
+                TyPatKind::NotNull => hir::TyPatKind::NotNull,
+                TyPatKind::Or(variants) => hir::TyPatKind::Or(self.arena.alloc_from_iter(
                     variants.iter().map(|pat| self.lower_ty_pat_mut(pat, base_type)),
-                ))
-            }
-            TyPatKind::Err(guar) => hir::TyPatKind::Err(*guar),
-        };
+                )),
+                TyPatKind::Err(guar) => hir::TyPatKind::Err(*guar),
+            };
 
         hir::TyPat { hir_id: pat_hir_id, kind: node, span: self.lower_span(pattern.span) }
     }