rustc_mir_build/thir/pattern/
const_to_pat.rs1use core::ops::ControlFlow;
2
3use rustc_abi::{FieldIdx, VariantIdx};
4use rustc_apfloat::Float;
5use rustc_data_structures::fx::FxHashSet;
6use rustc_errors::Diag;
7use rustc_hir as hir;
8use rustc_hir::attrs::AttributeKind;
9use rustc_hir::find_attr;
10use rustc_index::Idx;
11use rustc_infer::infer::TyCtxtInferExt;
12use rustc_infer::traits::Obligation;
13use rustc_middle::mir::interpret::ErrorHandled;
14use rustc_middle::span_bug;
15use rustc_middle::thir::{FieldPat, Pat, PatKind};
16use rustc_middle::ty::{
17 self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitableExt, TypeVisitor, ValTree,
18};
19use rustc_span::def_id::DefId;
20use rustc_span::{DUMMY_SP, Span};
21use rustc_trait_selection::traits::ObligationCause;
22use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
23use tracing::{debug, instrument, trace};
24
25use super::PatCtxt;
26use crate::errors::{
27 ConstPatternDependsOnGenericParameter, CouldNotEvalConstPattern, InvalidPattern, NaNPattern,
28 PointerPattern, TypeNotPartialEq, TypeNotStructural, UnionPattern, UnsizedPattern,
29};
30
31impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
32 #[instrument(level = "debug", skip(self), ret)]
40 pub(super) fn const_to_pat(
41 &self,
42 c: ty::Const<'tcx>,
43 ty: Ty<'tcx>,
44 id: hir::HirId,
45 span: Span,
46 ) -> Box<Pat<'tcx>> {
47 let mut convert = ConstToPat::new(self, id, span, c);
48
49 match c.kind() {
50 ty::ConstKind::Unevaluated(uv) => convert.unevaluated_to_pat(uv, ty),
51 ty::ConstKind::Value(cv) => convert.valtree_to_pat(cv.valtree, cv.ty),
52 _ => span_bug!(span, "Invalid `ConstKind` for `const_to_pat`: {:?}", c),
53 }
54 }
55}
56
57struct ConstToPat<'tcx> {
58 tcx: TyCtxt<'tcx>,
59 typing_env: ty::TypingEnv<'tcx>,
60 span: Span,
61 id: hir::HirId,
62
63 c: ty::Const<'tcx>,
64}
65
66impl<'tcx> ConstToPat<'tcx> {
67 fn new(pat_ctxt: &PatCtxt<'_, 'tcx>, id: hir::HirId, span: Span, c: ty::Const<'tcx>) -> Self {
68 trace!(?pat_ctxt.typeck_results.hir_owner);
69 ConstToPat { tcx: pat_ctxt.tcx, typing_env: pat_ctxt.typing_env, span, id, c }
70 }
71
72 fn type_marked_structural(&self, ty: Ty<'tcx>) -> bool {
73 ty.is_structural_eq_shallow(self.tcx)
74 }
75
76 fn mk_err(&self, mut err: Diag<'_>, ty: Ty<'tcx>) -> Box<Pat<'tcx>> {
78 if let ty::ConstKind::Unevaluated(uv) = self.c.kind() {
79 let def_kind = self.tcx.def_kind(uv.def);
80 if let hir::def::DefKind::AssocConst = def_kind
81 && let Some(def_id) = uv.def.as_local()
82 {
83 err.span_label(self.tcx.def_span(self.tcx.local_parent(def_id)), "");
85 }
86 if let hir::def::DefKind::Const | hir::def::DefKind::AssocConst = def_kind {
87 err.span_label(
88 self.tcx.def_span(uv.def),
89 crate::fluent_generated::mir_build_const_defined_here,
90 );
91 }
92 }
93 Box::new(Pat { span: self.span, ty, kind: PatKind::Error(err.emit()) })
94 }
95
96 fn unevaluated_to_pat(
97 &mut self,
98 uv: ty::UnevaluatedConst<'tcx>,
99 ty: Ty<'tcx>,
100 ) -> Box<Pat<'tcx>> {
101 let typing_env = self
109 .tcx
110 .erase_and_anonymize_regions(self.typing_env)
111 .with_post_analysis_normalized(self.tcx);
112 let uv = self.tcx.erase_and_anonymize_regions(uv);
113
114 let valtree = match self.tcx.const_eval_resolve_for_typeck(typing_env, uv, self.span) {
117 Ok(Ok(c)) => c,
118 Err(ErrorHandled::Reported(_, _)) => {
119 let mut err =
121 self.tcx.dcx().create_err(CouldNotEvalConstPattern { span: self.span });
122 if let ty::ConstKind::Unevaluated(uv) = self.c.kind()
125 && let hir::def::DefKind::Const | hir::def::DefKind::AssocConst =
126 self.tcx.def_kind(uv.def)
127 {
128 err.downgrade_to_delayed_bug();
129 }
130 return self.mk_err(err, ty);
131 }
132 Err(ErrorHandled::TooGeneric(_)) => {
133 let mut e = self
134 .tcx
135 .dcx()
136 .create_err(ConstPatternDependsOnGenericParameter { span: self.span });
137 for arg in uv.args {
138 if let ty::GenericArgKind::Type(ty) = arg.kind()
139 && let ty::Param(param_ty) = ty.kind()
140 {
141 let def_id = self.tcx.hir_enclosing_body_owner(self.id);
142 let generics = self.tcx.generics_of(def_id);
143 let param = generics.type_param(*param_ty, self.tcx);
144 let span = self.tcx.def_span(param.def_id);
145 e.span_label(span, "constant depends on this generic parameter");
146 if let Some(ident) = self.tcx.def_ident_span(def_id)
147 && self.tcx.sess.source_map().is_multiline(ident.between(span))
148 {
149 e.span_label(ident, "");
152 }
153 }
154 }
155 return self.mk_err(e, ty);
156 }
157 Ok(Err(bad_ty)) => {
158 let e = match bad_ty.kind() {
160 ty::Adt(def, ..) => {
161 assert!(def.is_union());
162 self.tcx.dcx().create_err(UnionPattern { span: self.span })
163 }
164 ty::FnPtr(..) | ty::RawPtr(..) => {
165 self.tcx.dcx().create_err(PointerPattern { span: self.span })
166 }
167 _ => self.tcx.dcx().create_err(InvalidPattern {
168 span: self.span,
169 non_sm_ty: bad_ty,
170 prefix: bad_ty.prefix_string(self.tcx).to_string(),
171 }),
172 };
173 return self.mk_err(e, ty);
174 }
175 };
176
177 let inlined_const_as_pat = self.valtree_to_pat(valtree, ty);
179
180 if !inlined_const_as_pat.references_error() {
181 if !type_has_partial_eq_impl(self.tcx, typing_env, ty).has_impl {
183 let mut err = self.tcx.dcx().create_err(TypeNotPartialEq { span: self.span, ty });
184 extend_type_not_partial_eq(self.tcx, typing_env, ty, &mut err);
185 return self.mk_err(err, ty);
186 }
187 }
188
189 let kind = PatKind::ExpandedConstant { subpattern: inlined_const_as_pat, def_id: uv.def };
192 Box::new(Pat { kind, ty, span: self.span })
193 }
194
195 fn field_pats(
196 &self,
197 vals: impl Iterator<Item = (ValTree<'tcx>, Ty<'tcx>)>,
198 ) -> Vec<FieldPat<'tcx>> {
199 vals.enumerate()
200 .map(|(idx, (val, ty))| {
201 let field = FieldIdx::new(idx);
202 let ty = self.tcx.normalize_erasing_regions(self.typing_env, ty);
204 FieldPat { field, pattern: *self.valtree_to_pat(val, ty) }
205 })
206 .collect()
207 }
208
209 #[instrument(skip(self), level = "debug")]
212 fn valtree_to_pat(&self, cv: ValTree<'tcx>, ty: Ty<'tcx>) -> Box<Pat<'tcx>> {
213 let span = self.span;
214 let tcx = self.tcx;
215 let kind = match ty.kind() {
216 ty::Adt(adt_def, _) if !self.type_marked_structural(ty) => {
217 debug!("adt_def {:?} has !type_marked_structural for cv.ty: {:?}", adt_def, ty);
220 let PartialEqImplStatus {
221 is_derived, structural_partial_eq, non_blanket_impl, ..
222 } = type_has_partial_eq_impl(self.tcx, self.typing_env, ty);
223 let (manual_partialeq_impl_span, manual_partialeq_impl_note) =
224 match (structural_partial_eq, non_blanket_impl) {
225 (true, _) => (None, false),
226 (_, Some(def_id)) if def_id.is_local() && !is_derived => {
227 (Some(tcx.def_span(def_id)), false)
228 }
229 _ => (None, true),
230 };
231 let ty_def_span = tcx.def_span(adt_def.did());
232 let err = TypeNotStructural {
233 span,
234 ty,
235 ty_def_span,
236 manual_partialeq_impl_span,
237 manual_partialeq_impl_note,
238 };
239 return self.mk_err(tcx.dcx().create_err(err), ty);
240 }
241 ty::Adt(adt_def, args) if adt_def.is_enum() => {
242 let (&variant_index, fields) = cv.unwrap_branch().split_first().unwrap();
243 let variant_index = VariantIdx::from_u32(variant_index.unwrap_leaf().to_u32());
244 PatKind::Variant {
245 adt_def: *adt_def,
246 args,
247 variant_index,
248 subpatterns: self.field_pats(
249 fields.iter().copied().zip(
250 adt_def.variants()[variant_index]
251 .fields
252 .iter()
253 .map(|field| field.ty(tcx, args)),
254 ),
255 ),
256 }
257 }
258 ty::Adt(def, args) => {
259 assert!(!def.is_union()); PatKind::Leaf {
261 subpatterns: self.field_pats(cv.unwrap_branch().iter().copied().zip(
262 def.non_enum_variant().fields.iter().map(|field| field.ty(tcx, args)),
263 )),
264 }
265 }
266 ty::Tuple(fields) => PatKind::Leaf {
267 subpatterns: self.field_pats(cv.unwrap_branch().iter().copied().zip(fields.iter())),
268 },
269 ty::Slice(elem_ty) => PatKind::Slice {
270 prefix: cv
271 .unwrap_branch()
272 .iter()
273 .map(|val| *self.valtree_to_pat(*val, *elem_ty))
274 .collect(),
275 slice: None,
276 suffix: Box::new([]),
277 },
278 ty::Array(elem_ty, _) => PatKind::Array {
279 prefix: cv
280 .unwrap_branch()
281 .iter()
282 .map(|val| *self.valtree_to_pat(*val, *elem_ty))
283 .collect(),
284 slice: None,
285 suffix: Box::new([]),
286 },
287 ty::Str => {
288 let ref_str_ty = Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, ty);
293 PatKind::Constant { value: ty::Value { ty: ref_str_ty, valtree: cv } }
294 }
295 ty::Ref(_, pointee_ty, ..) => match *pointee_ty.kind() {
296 ty::Str => PatKind::Constant { value: ty::Value { ty, valtree: cv } },
299 _ => {
303 if !pointee_ty.is_sized(tcx, self.typing_env) && !pointee_ty.is_slice() {
304 return self.mk_err(
305 tcx.dcx().create_err(UnsizedPattern { span, non_sm_ty: *pointee_ty }),
306 ty,
307 );
308 } else {
309 PatKind::Deref { subpattern: self.valtree_to_pat(cv, *pointee_ty) }
311 }
312 }
313 },
314 ty::Float(flt) => {
315 let v = cv.unwrap_leaf();
316 let is_nan = match flt {
317 ty::FloatTy::F16 => v.to_f16().is_nan(),
318 ty::FloatTy::F32 => v.to_f32().is_nan(),
319 ty::FloatTy::F64 => v.to_f64().is_nan(),
320 ty::FloatTy::F128 => v.to_f128().is_nan(),
321 };
322 if is_nan {
323 return self.mk_err(tcx.dcx().create_err(NaNPattern { span }), ty);
326 } else {
327 PatKind::Constant { value: ty::Value { ty, valtree: cv } }
328 }
329 }
330 ty::Pat(..) | ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::RawPtr(..) => {
331 PatKind::Constant { value: ty::Value { ty, valtree: cv } }
334 }
335 ty::FnPtr(..) => {
336 unreachable!(
337 "Valtree construction would never succeed for FnPtr, so this is unreachable."
338 )
339 }
340 _ => {
341 let err = InvalidPattern {
342 span,
343 non_sm_ty: ty,
344 prefix: ty.prefix_string(tcx).to_string(),
345 };
346 return self.mk_err(tcx.dcx().create_err(err), ty);
347 }
348 };
349
350 Box::new(Pat { span, ty, kind })
351 }
352}
353
354fn extend_type_not_partial_eq<'tcx>(
357 tcx: TyCtxt<'tcx>,
358 typing_env: ty::TypingEnv<'tcx>,
359 ty: Ty<'tcx>,
360 err: &mut Diag<'_>,
361) {
362 struct UsedParamsNeedInstantiationVisitor<'tcx> {
364 tcx: TyCtxt<'tcx>,
365 typing_env: ty::TypingEnv<'tcx>,
366 adts_with_manual_partialeq: FxHashSet<Span>,
368 adts_without_partialeq: FxHashSet<Span>,
370 manual: FxHashSet<Ty<'tcx>>,
373 without: FxHashSet<Ty<'tcx>>,
376 }
377
378 impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for UsedParamsNeedInstantiationVisitor<'tcx> {
379 type Result = ControlFlow<()>;
380 fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
381 match ty.kind() {
382 ty::Dynamic(..) => return ControlFlow::Break(()),
383 ty::UnsafeBinder(..) => return ControlFlow::Break(()),
386 ty::FnPtr(..) => return ControlFlow::Continue(()),
387 ty::Adt(def, _args) => {
388 let ty_def_id = def.did();
389 let ty_def_span = self.tcx.def_span(ty_def_id);
390 let PartialEqImplStatus {
391 has_impl,
392 is_derived,
393 structural_partial_eq,
394 non_blanket_impl,
395 } = type_has_partial_eq_impl(self.tcx, self.typing_env, ty);
396 match (has_impl, is_derived, structural_partial_eq, non_blanket_impl) {
397 (_, _, true, _) => {}
398 (true, false, _, Some(def_id)) if def_id.is_local() => {
399 self.adts_with_manual_partialeq.insert(self.tcx.def_span(def_id));
400 }
401 (true, false, _, _) if ty_def_id.is_local() => {
402 self.adts_with_manual_partialeq.insert(ty_def_span);
403 }
404 (false, _, _, _) if ty_def_id.is_local() => {
405 self.adts_without_partialeq.insert(ty_def_span);
406 }
407 (true, false, _, _) => {
408 self.manual.insert(ty);
409 }
410 (false, _, _, _) => {
411 self.without.insert(ty);
412 }
413 _ => {}
414 };
415 ty.super_visit_with(self)
416 }
417 _ => ty.super_visit_with(self),
418 }
419 }
420 }
421 let mut v = UsedParamsNeedInstantiationVisitor {
422 tcx,
423 typing_env,
424 adts_with_manual_partialeq: FxHashSet::default(),
425 adts_without_partialeq: FxHashSet::default(),
426 manual: FxHashSet::default(),
427 without: FxHashSet::default(),
428 };
429 if v.visit_ty(ty).is_break() {
430 return;
431 }
432 #[allow(rustc::potential_query_instability)] for span in v.adts_with_manual_partialeq {
434 err.span_note(span, "the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details");
435 }
436 #[allow(rustc::potential_query_instability)] for span in v.adts_without_partialeq {
438 err.span_label(
439 span,
440 "must be annotated with `#[derive(PartialEq)]` to be usable in patterns",
441 );
442 }
443 #[allow(rustc::potential_query_instability)]
444 let mut manual: Vec<_> = v.manual.into_iter().map(|t| t.to_string()).collect();
445 manual.sort();
446 for ty in manual {
447 err.note(format!(
448 "`{ty}` must be annotated with `#[derive(PartialEq)]` to be usable in patterns, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details"
449 ));
450 }
451 #[allow(rustc::potential_query_instability)]
452 let mut without: Vec<_> = v.without.into_iter().map(|t| t.to_string()).collect();
453 without.sort();
454 for ty in without {
455 err.note(format!(
456 "`{ty}` must be annotated with `#[derive(PartialEq)]` to be usable in patterns"
457 ));
458 }
459}
460
461#[derive(Debug)]
462struct PartialEqImplStatus {
463 has_impl: bool,
464 is_derived: bool,
465 structural_partial_eq: bool,
466 non_blanket_impl: Option<DefId>,
467}
468
469#[instrument(level = "trace", skip(tcx), ret)]
470fn type_has_partial_eq_impl<'tcx>(
471 tcx: TyCtxt<'tcx>,
472 typing_env: ty::TypingEnv<'tcx>,
473 ty: Ty<'tcx>,
474) -> PartialEqImplStatus {
475 let (infcx, param_env) = tcx.infer_ctxt().build_with_typing_env(typing_env);
476 let partial_eq_trait_id = tcx.require_lang_item(hir::LangItem::PartialEq, DUMMY_SP);
482 let structural_partial_eq_trait_id =
483 tcx.require_lang_item(hir::LangItem::StructuralPeq, DUMMY_SP);
484
485 let partial_eq_obligation = Obligation::new(
486 tcx,
487 ObligationCause::dummy(),
488 param_env,
489 ty::TraitRef::new(tcx, partial_eq_trait_id, [ty, ty]),
490 );
491
492 let mut automatically_derived = false;
493 let mut structural_peq = false;
494 let mut impl_def_id = None;
495 for def_id in tcx.non_blanket_impls_for_ty(partial_eq_trait_id, ty) {
496 automatically_derived =
497 find_attr!(tcx.get_all_attrs(def_id), AttributeKind::AutomaticallyDerived(..));
498 impl_def_id = Some(def_id);
499 }
500 for _ in tcx.non_blanket_impls_for_ty(structural_partial_eq_trait_id, ty) {
501 structural_peq = true;
502 }
503 PartialEqImplStatus {
514 has_impl: infcx.predicate_must_hold_modulo_regions(&partial_eq_obligation),
515 is_derived: automatically_derived,
516 structural_partial_eq: structural_peq,
517 non_blanket_impl: impl_def_id,
518 }
519}