rustc_mir_build/thir/pattern/
const_to_pat.rs

1use 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<'tcx> PatCtxt<'tcx> {
32    /// Converts a constant to a pattern (if possible).
33    /// This means aggregate values (like structs and enums) are converted
34    /// to a pattern that matches the value (as if you'd compared via structural equality).
35    ///
36    /// Only type system constants are supported, as we are using valtrees
37    /// as an intermediate step. Unfortunately those don't carry a type
38    /// so we have to carry one ourselves.
39    #[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    /// We errored. Signal that in the pattern, so that follow up errors can be silenced.
77    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                // Include the container item in the output.
84                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()), extra: None })
94    }
95
96    fn unevaluated_to_pat(
97        &mut self,
98        uv: ty::UnevaluatedConst<'tcx>,
99        ty: Ty<'tcx>,
100    ) -> Box<Pat<'tcx>> {
101        // It's not *technically* correct to be revealing opaque types here as borrowcheck has
102        // not run yet. However, CTFE itself uses `TypingMode::PostAnalysis` unconditionally even
103        // during typeck and not doing so has a lot of (undesirable) fallout (#101478, #119821).
104        // As a result we always use a revealed env when resolving the instance to evaluate.
105        //
106        // FIXME: `const_eval_resolve_for_typeck` should probably just modify the env itself
107        // instead of having this logic here
108        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        // try to resolve e.g. associated constants to their definition on an impl, and then
115        // evaluate the const.
116        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's tell the use where this failing const occurs.
120                let mut err =
121                    self.tcx.dcx().create_err(CouldNotEvalConstPattern { span: self.span });
122                // We've emitted an error on the original const, it would be redundant to complain
123                // on its use as well.
124                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                            // Display the `fn` name as well in the diagnostic, as the generic isn't
150                            // in the same line and it could be confusing otherwise.
151                            e.span_label(ident, "");
152                        }
153                    }
154                }
155                return self.mk_err(e, ty);
156            }
157            Ok(Err(bad_ty)) => {
158                // The pattern cannot be turned into a valtree.
159                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        // Lower the valtree to a THIR pattern.
178        let mut thir_pat = self.valtree_to_pat(valtree, ty);
179
180        if !thir_pat.references_error() {
181            // Always check for `PartialEq` if we had no other errors yet.
182            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        // Mark the pattern to indicate that it is the result of lowering a named
190        // constant. This is used for diagnostics.
191        thir_pat.extra.get_or_insert_default().expanded_const = Some(uv.def);
192        thir_pat
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                // Patterns can only use monomorphic types.
203                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    // Recursive helper for `to_pat`; invoke that (instead of calling this directly).
210    // FIXME(valtrees): Accept `ty::Value` instead of `Ty` and `ty::ValTree` separately.
211    #[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                // Extremely important check for all ADTs! Make sure they opted-in to be used in
218                // patterns.
219                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.to_branch().split_first().unwrap();
243                let variant_index = VariantIdx::from_u32(variant_index.to_leaf().to_u32());
244                PatKind::Variant {
245                    adt_def: *adt_def,
246                    args,
247                    variant_index,
248                    subpatterns: self.field_pats(
249                        fields.iter().map(|ct| ct.to_value().valtree).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()); // Valtree construction would never succeed for unions.
260                PatKind::Leaf {
261                    subpatterns: self.field_pats(
262                        cv.to_branch().iter().map(|ct| ct.to_value().valtree).zip(
263                            def.non_enum_variant().fields.iter().map(|field| field.ty(tcx, args)),
264                        ),
265                    ),
266                }
267            }
268            ty::Tuple(fields) => PatKind::Leaf {
269                subpatterns: self.field_pats(
270                    cv.to_branch().iter().map(|ct| ct.to_value().valtree).zip(fields.iter()),
271                ),
272            },
273            ty::Slice(elem_ty) => PatKind::Slice {
274                prefix: cv
275                    .to_branch()
276                    .iter()
277                    .map(|val| *self.valtree_to_pat(val.to_value().valtree, *elem_ty))
278                    .collect(),
279                slice: None,
280                suffix: Box::new([]),
281            },
282            ty::Array(elem_ty, _) => PatKind::Array {
283                prefix: cv
284                    .to_branch()
285                    .iter()
286                    .map(|val| *self.valtree_to_pat(val.to_value().valtree, *elem_ty))
287                    .collect(),
288                slice: None,
289                suffix: Box::new([]),
290            },
291            ty::Str => {
292                // String literal patterns may have type `str` if `deref_patterns` is enabled, in
293                // order to allow `deref!("..."): String`. Since we need a `&str` for the comparison
294                // when lowering to MIR in `Builder::perform_test`, treat the constant as a `&str`.
295                // This works because `str` and `&str` have the same valtree representation.
296                let ref_str_ty = Ty::new_imm_ref(tcx, tcx.lifetimes.re_erased, ty);
297                PatKind::Constant { value: ty::Value { ty: ref_str_ty, valtree: cv } }
298            }
299            ty::Ref(_, pointee_ty, ..) => match *pointee_ty.kind() {
300                // `&str` is represented as a valtree, let's keep using this
301                // optimization for now.
302                ty::Str => PatKind::Constant { value: ty::Value { ty, valtree: cv } },
303                // All other references are converted into deref patterns and then recursively
304                // convert the dereferenced constant to a pattern that is the sub-pattern of the
305                // deref pattern.
306                _ => {
307                    if !pointee_ty.is_sized(tcx, self.typing_env) && !pointee_ty.is_slice() {
308                        return self.mk_err(
309                            tcx.dcx().create_err(UnsizedPattern { span, non_sm_ty: *pointee_ty }),
310                            ty,
311                        );
312                    } else {
313                        // References have the same valtree representation as their pointee.
314                        PatKind::Deref { subpattern: self.valtree_to_pat(cv, *pointee_ty) }
315                    }
316                }
317            },
318            ty::Float(flt) => {
319                let v = cv.to_leaf();
320                let is_nan = match flt {
321                    ty::FloatTy::F16 => v.to_f16().is_nan(),
322                    ty::FloatTy::F32 => v.to_f32().is_nan(),
323                    ty::FloatTy::F64 => v.to_f64().is_nan(),
324                    ty::FloatTy::F128 => v.to_f128().is_nan(),
325                };
326                if is_nan {
327                    // NaNs are not ever equal to anything so they make no sense as patterns.
328                    // Also see <https://github.com/rust-lang/rfcs/pull/3535>.
329                    return self.mk_err(tcx.dcx().create_err(NaNPattern { span }), ty);
330                } else {
331                    PatKind::Constant { value: ty::Value { ty, valtree: cv } }
332                }
333            }
334            ty::Pat(..) | ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::RawPtr(..) => {
335                // The raw pointers we see here have been "vetted" by valtree construction to be
336                // just integers, so we simply allow them.
337                PatKind::Constant { value: ty::Value { ty, valtree: cv } }
338            }
339            ty::FnPtr(..) => {
340                unreachable!(
341                    "Valtree construction would never succeed for FnPtr, so this is unreachable."
342                )
343            }
344            _ => {
345                let err = InvalidPattern {
346                    span,
347                    non_sm_ty: ty,
348                    prefix: ty.prefix_string(tcx).to_string(),
349                };
350                return self.mk_err(tcx.dcx().create_err(err), ty);
351            }
352        };
353
354        Box::new(Pat { span, ty, kind, extra: None })
355    }
356}
357
358/// Given a type with type parameters, visit every ADT looking for types that need to
359/// `#[derive(PartialEq)]` for it to be a structural type.
360fn extend_type_not_partial_eq<'tcx>(
361    tcx: TyCtxt<'tcx>,
362    typing_env: ty::TypingEnv<'tcx>,
363    ty: Ty<'tcx>,
364    err: &mut Diag<'_>,
365) {
366    /// Collect all types that need to be `StructuralPartialEq`.
367    struct UsedParamsNeedInstantiationVisitor<'tcx> {
368        tcx: TyCtxt<'tcx>,
369        typing_env: ty::TypingEnv<'tcx>,
370        /// The user has written `impl PartialEq for Ty` which means it's non-structural.
371        adts_with_manual_partialeq: FxHashSet<Span>,
372        /// The type has no `PartialEq` implementation, neither manual or derived.
373        adts_without_partialeq: FxHashSet<Span>,
374        /// The user has written `impl PartialEq for Ty` which means it's non-structural,
375        /// but we don't have a span to point at, so we'll just add them as a `note`.
376        manual: FxHashSet<Ty<'tcx>>,
377        /// The type has no `PartialEq` implementation, neither manual or derived, but
378        /// we don't have a span to point at, so we'll just add them as a `note`.
379        without: FxHashSet<Ty<'tcx>>,
380    }
381
382    impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for UsedParamsNeedInstantiationVisitor<'tcx> {
383        type Result = ControlFlow<()>;
384        fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
385            match ty.kind() {
386                ty::Dynamic(..) => return ControlFlow::Break(()),
387                // Unsafe binders never implement `PartialEq`, so avoid walking into them
388                // which would require instantiating its binder with placeholders too.
389                ty::UnsafeBinder(..) => return ControlFlow::Break(()),
390                ty::FnPtr(..) => return ControlFlow::Continue(()),
391                ty::Adt(def, _args) => {
392                    let ty_def_id = def.did();
393                    let ty_def_span = self.tcx.def_span(ty_def_id);
394                    let PartialEqImplStatus {
395                        has_impl,
396                        is_derived,
397                        structural_partial_eq,
398                        non_blanket_impl,
399                    } = type_has_partial_eq_impl(self.tcx, self.typing_env, ty);
400                    match (has_impl, is_derived, structural_partial_eq, non_blanket_impl) {
401                        (_, _, true, _) => {}
402                        (true, false, _, Some(def_id)) if def_id.is_local() => {
403                            self.adts_with_manual_partialeq.insert(self.tcx.def_span(def_id));
404                        }
405                        (true, false, _, _) if ty_def_id.is_local() => {
406                            self.adts_with_manual_partialeq.insert(ty_def_span);
407                        }
408                        (false, _, _, _) if ty_def_id.is_local() => {
409                            self.adts_without_partialeq.insert(ty_def_span);
410                        }
411                        (true, false, _, _) => {
412                            self.manual.insert(ty);
413                        }
414                        (false, _, _, _) => {
415                            self.without.insert(ty);
416                        }
417                        _ => {}
418                    };
419                    ty.super_visit_with(self)
420                }
421                _ => ty.super_visit_with(self),
422            }
423        }
424    }
425    let mut v = UsedParamsNeedInstantiationVisitor {
426        tcx,
427        typing_env,
428        adts_with_manual_partialeq: FxHashSet::default(),
429        adts_without_partialeq: FxHashSet::default(),
430        manual: FxHashSet::default(),
431        without: FxHashSet::default(),
432    };
433    if v.visit_ty(ty).is_break() {
434        return;
435    }
436    #[allow(rustc::potential_query_instability)] // Span labels will be sorted by the rendering
437    for span in v.adts_with_manual_partialeq {
438        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");
439    }
440    #[allow(rustc::potential_query_instability)] // Span labels will be sorted by the rendering
441    for span in v.adts_without_partialeq {
442        err.span_label(
443            span,
444            "must be annotated with `#[derive(PartialEq)]` to be usable in patterns",
445        );
446    }
447    #[allow(rustc::potential_query_instability)]
448    let mut manual: Vec<_> = v.manual.into_iter().map(|t| t.to_string()).collect();
449    manual.sort();
450    for ty in manual {
451        err.note(format!(
452            "`{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"
453        ));
454    }
455    #[allow(rustc::potential_query_instability)]
456    let mut without: Vec<_> = v.without.into_iter().map(|t| t.to_string()).collect();
457    without.sort();
458    for ty in without {
459        err.note(format!(
460            "`{ty}` must be annotated with `#[derive(PartialEq)]` to be usable in patterns"
461        ));
462    }
463}
464
465#[derive(Debug)]
466struct PartialEqImplStatus {
467    has_impl: bool,
468    is_derived: bool,
469    structural_partial_eq: bool,
470    non_blanket_impl: Option<DefId>,
471}
472
473#[instrument(level = "trace", skip(tcx), ret)]
474fn type_has_partial_eq_impl<'tcx>(
475    tcx: TyCtxt<'tcx>,
476    typing_env: ty::TypingEnv<'tcx>,
477    ty: Ty<'tcx>,
478) -> PartialEqImplStatus {
479    let (infcx, param_env) = tcx.infer_ctxt().build_with_typing_env(typing_env);
480    // double-check there even *is* a semantic `PartialEq` to dispatch to.
481    //
482    // (If there isn't, then we can safely issue a hard
483    // error, because that's never worked, due to compiler
484    // using `PartialEq::eq` in this scenario in the past.)
485    let partial_eq_trait_id = tcx.require_lang_item(hir::LangItem::PartialEq, DUMMY_SP);
486    let structural_partial_eq_trait_id =
487        tcx.require_lang_item(hir::LangItem::StructuralPeq, DUMMY_SP);
488
489    let partial_eq_obligation = Obligation::new(
490        tcx,
491        ObligationCause::dummy(),
492        param_env,
493        ty::TraitRef::new(tcx, partial_eq_trait_id, [ty, ty]),
494    );
495
496    let mut automatically_derived = false;
497    let mut structural_peq = false;
498    let mut impl_def_id = None;
499    for def_id in tcx.non_blanket_impls_for_ty(partial_eq_trait_id, ty) {
500        automatically_derived =
501            find_attr!(tcx.get_all_attrs(def_id), AttributeKind::AutomaticallyDerived(..));
502        impl_def_id = Some(def_id);
503    }
504    for _ in tcx.non_blanket_impls_for_ty(structural_partial_eq_trait_id, ty) {
505        structural_peq = true;
506    }
507    // This *could* accept a type that isn't actually `PartialEq`, because region bounds get
508    // ignored. However that should be pretty much impossible since consts that do not depend on
509    // generics can only mention the `'static` lifetime, and how would one have a type that's
510    // `PartialEq` for some lifetime but *not* for `'static`? If this ever becomes a problem
511    // we'll need to leave some sort of trace of this requirement in the MIR so that borrowck
512    // can ensure that the type really implements `PartialEq`.
513    // We also do *not* require `const PartialEq`, not even in `const fn`. This violates the model
514    // that patterns can only do things that the code could also do without patterns, but it is
515    // needed for backwards compatibility. The actual pattern matching compares primitive values,
516    // `PartialEq::eq` never gets invoked, so there's no risk of us running non-const code.
517    PartialEqImplStatus {
518        has_impl: infcx.predicate_must_hold_modulo_regions(&partial_eq_obligation),
519        is_derived: automatically_derived,
520        structural_partial_eq: structural_peq,
521        non_blanket_impl: impl_def_id,
522    }
523}
rustc_mir_build/thir/pattern/const_to_pat.rs

rustc_mir_build/thir/pattern/
const_to_pat.rs
