Pull PatExpr lowering out into a dedicated function

Author: oli-obk

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -2441,54 +2441,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         Ty::new_error(tcx, err)
                     }
                     hir::PatKind::Range(start, end, include_end) => {
-                        let expr_to_const = |expr: &'tcx hir::PatExpr<'tcx>| -> ty::Const<'tcx> {
-                            let (c, c_ty) = match expr.kind {
-                                hir::PatExprKind::Lit { lit, negated } => {
-                                    let lit_input =
-                                        LitToConstInput { lit: &lit.node, ty, neg: negated };
-                                    let ct = tcx.lit_to_const(lit_input);
-                                    (ct, ty)
-                                }
-
-                                hir::PatExprKind::Path(hir::QPath::Resolved(
-                                    _,
-                                    path @ &hir::Path {
-                                        res: Res::Def(DefKind::ConstParam, def_id),
-                                        ..
-                                    },
-                                )) => {
-                                    match self.prohibit_generic_args(
-                                        path.segments.iter(),
-                                        GenericsArgsErrExtend::Param(def_id),
-                                    ) {
-                                        Ok(()) => {
-                                            let ty = tcx
-                                                .type_of(def_id)
-                                                .no_bound_vars()
-                                                .expect("const parameter types cannot be generic");
-                                            let ct = self.lower_const_param(def_id, expr.hir_id);
-                                            (ct, ty)
-                                        }
-                                        Err(guar) => (
-                                            ty::Const::new_error(tcx, guar),
-                                            Ty::new_error(tcx, guar),
-                                        ),
-                                    }
-                                }
-
-                                _ => {
-                                    let err = tcx
-                                        .dcx()
-                                        .emit_err(crate::errors::NonConstRange { span: expr.span });
-                                    (ty::Const::new_error(tcx, err), Ty::new_error(tcx, err))
-                                }
-                            };
-                            self.record_ty(expr.hir_id, c_ty, expr.span);
-                            c
-                        };
-
-                        let start = start.map(expr_to_const);
-                        let end = end.map(expr_to_const);
+                        let start = start.map(|expr| self.lower_pat_expr(expr, ty));
+                        let end = end.map(|expr| self.lower_pat_expr(expr, ty));
 
                         let include_end = match include_end {
                             hir::RangeEnd::Included => true,
@@ -2515,6 +2469,44 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         result_ty
     }
 
+    fn lower_pat_expr(&self, expr: &'tcx hir::PatExpr<'tcx>, ty: Ty<'tcx>) -> ty::Const<'tcx> {
+        let tcx = self.tcx();
+        let (c, c_ty) = match expr.kind {
+            hir::PatExprKind::Lit { lit, negated } => {
+                let lit_input = LitToConstInput { lit: &lit.node, ty, neg: negated };
+                let ct = tcx.lit_to_const(lit_input);
+                (ct, ty)
+            }
+
+            hir::PatExprKind::Path(hir::QPath::Resolved(
+                _,
+                path @ &hir::Path { res: Res::Def(DefKind::ConstParam, def_id), .. },
+            )) => {
+                match self.prohibit_generic_args(
+                    path.segments.iter(),
+                    GenericsArgsErrExtend::Param(def_id),
+                ) {
+                    Ok(()) => {
+                        let ty = tcx
+                            .type_of(def_id)
+                            .no_bound_vars()
+                            .expect("const parameter types cannot be generic");
+                        let ct = self.lower_const_param(def_id, expr.hir_id);
+                        (ct, ty)
+                    }
+                    Err(guar) => (ty::Const::new_error(tcx, guar), Ty::new_error(tcx, guar)),
+                }
+            }
+
+            _ => {
+                let err = tcx.dcx().emit_err(crate::errors::NonConstRange { span: expr.span });
+                (ty::Const::new_error(tcx, err), Ty::new_error(tcx, err))
+            }
+        };
+        self.record_ty(expr.hir_id, c_ty, expr.span);
+        c
+    }
+
     /// Lower an opaque type (i.e., an existential impl-Trait type) from the HIR.
     #[instrument(level = "debug", skip(self), ret)]
     fn lower_opaque_ty(&self, def_id: LocalDefId, in_trait: bool) -> Ty<'tcx> {