bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Tweak lower_pat_expr

Browse source
This commit is contained in:
Nadrieril 2025-03-29 12:32:07 +01:00
parent 090d76497f
commit 50e10b37c0
1 changed files with 33 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

68
compiler/rustc_mir_build/src/thir/pattern/mod.rs
View file

@ -617,43 +617,41 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
expr: &'tcx hir::PatExpr<'tcx>, expr: &'tcx hir::PatExpr<'tcx>,
pat_ty: Option<Ty<'tcx>>, pat_ty: Option<Ty<'tcx>>,
) -> PatKind<'tcx> { ) -> PatKind<'tcx> {
let (lit, neg) = match &expr.kind { match &expr.kind {
hir::PatExprKind::Path(qpath) => { hir::PatExprKind::Path(qpath) => self.lower_path(qpath, expr.hir_id, expr.span).kind,
return self.lower_path(qpath, expr.hir_id, expr.span).kind;
}
hir::PatExprKind::ConstBlock(anon_const) => { hir::PatExprKind::ConstBlock(anon_const) => {
return self.lower_inline_const(anon_const, expr.hir_id, expr.span); self.lower_inline_const(anon_const, expr.hir_id, expr.span)
} }
hir::PatExprKind::Lit { lit, negated } => (lit, *negated), hir::PatExprKind::Lit { lit, negated } => {
}; // We handle byte string literal patterns by using the pattern's type instead of the
// literal's type in `const_to_pat`: if the literal `b"..."` matches on a slice reference,
// We handle byte string literal patterns by using the pattern's type instead of the // the pattern's type will be `&[u8]` whereas the literal's type is `&[u8; 3]`; using the
// literal's type in `const_to_pat`: if the literal `b"..."` matches on a slice reference, // pattern's type means we'll properly translate it to a slice reference pattern. This works
// the pattern's type will be `&[u8]` whereas the literal's type is `&[u8; 3]`; using the // because slices and arrays have the same valtree representation.
// pattern's type means we'll properly translate it to a slice reference pattern. This works // HACK: As an exception, use the literal's type if `pat_ty` is `String`; this can happen if
// because slices and arrays have the same valtree representation. // `string_deref_patterns` is enabled. There's a special case for that when lowering to MIR.
// HACK: As an exception, use the literal's type if `pat_ty` is `String`; this can happen if // FIXME(deref_patterns): This hack won't be necessary once `string_deref_patterns` is
// `string_deref_patterns` is enabled. There's a special case for that when lowering to MIR. // superseded by a more general implementation of deref patterns.
// FIXME(deref_patterns): This hack won't be necessary once `string_deref_patterns` is let ct_ty = match pat_ty {
// superseded by a more general implementation of deref patterns. Some(pat_ty)
let ct_ty = match pat_ty { if let ty::Adt(def, _) = *pat_ty.kind()
Some(pat_ty) && self.tcx.is_lang_item(def.did(), LangItem::String) =>
if let ty::Adt(def, _) = *pat_ty.kind() {
&& self.tcx.is_lang_item(def.did(), LangItem::String) => if !self.tcx.features().string_deref_patterns() {
{ span_bug!(
if !self.tcx.features().string_deref_patterns() { expr.span,
span_bug!( "matching on `String` went through without enabling string_deref_patterns"
expr.span, );
"matching on `String` went through without enabling string_deref_patterns" }
); self.typeck_results.node_type(expr.hir_id)
} }
self.typeck_results.node_type(expr.hir_id) Some(pat_ty) => pat_ty,
None => self.typeck_results.node_type(expr.hir_id),
};
let lit_input = LitToConstInput { lit: &lit.node, ty: ct_ty, neg: *negated };
let constant = self.tcx.at(expr.span).lit_to_const(lit_input);
self.const_to_pat(constant, ct_ty, expr.hir_id, lit.span).kind
} }
Some(pat_ty) => pat_ty, }
None => self.typeck_results.node_type(expr.hir_id),
};
let lit_input = LitToConstInput { lit: &lit.node, ty: ct_ty, neg };
let constant = self.tcx.at(expr.span).lit_to_const(lit_input);
self.const_to_pat(constant, ct_ty, expr.hir_id, lit.span).kind
} }
} }