compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs

   1 //! Structural const qualification.
   2 //!
   3 //! See the `Qualif` trait for more info.
   4
   5 use rustc_errors::ErrorGuaranteed;
   6 use rustc_hir::LangItem;
   7 use rustc_infer::infer::TyCtxtInferExt;
   8 use rustc_middle::mir;
   9 use rustc_middle::mir::*;
  10 use rustc_middle::ty::{self, subst::SubstsRef, AdtDef, Ty};
  11 use rustc_trait_selection::traits::{
  12     self, ImplSource, Obligation, ObligationCause, SelectionContext,
  13 };
  14
  15 use super::ConstCx;
  16
  17 pub fn in_any_value_of_ty<'tcx>(
  18     cx: &ConstCx<'_, 'tcx>,
  19     ty: Ty<'tcx>,
  20     tainted_by_errors: Option<ErrorGuaranteed>,
  21 ) -> ConstQualifs {
  22     ConstQualifs {
  23         has_mut_interior: HasMutInterior::in_any_value_of_ty(cx, ty),
  24         needs_drop: NeedsDrop::in_any_value_of_ty(cx, ty),
  25         needs_non_const_drop: NeedsNonConstDrop::in_any_value_of_ty(cx, ty),
  26         custom_eq: CustomEq::in_any_value_of_ty(cx, ty),
  27         tainted_by_errors,
  28     }
  29 }
  30
  31 /// A "qualif"(-ication) is a way to look for something "bad" in the MIR that would disqualify some
  32 /// code for promotion or prevent it from evaluating at compile time.
  33 ///
  34 /// Normally, we would determine what qualifications apply to each type and error when an illegal
  35 /// operation is performed on such a type. However, this was found to be too imprecise, especially
  36 /// in the presence of `enum`s. If only a single variant of an enum has a certain qualification, we
  37 /// needn't reject code unless it actually constructs and operates on the qualified variant.
  38 ///
  39 /// To accomplish this, const-checking and promotion use a value-based analysis (as opposed to a
  40 /// type-based one). Qualifications propagate structurally across variables: If a local (or a
  41 /// projection of a local) is assigned a qualified value, that local itself becomes qualified.
  42 pub trait Qualif {
  43     /// The name of the file used to debug the dataflow analysis that computes this qualif.
  44     const ANALYSIS_NAME: &'static str;
  45
  46     /// Whether this `Qualif` is cleared when a local is moved from.
  47     const IS_CLEARED_ON_MOVE: bool = false;
  48
  49     /// Whether this `Qualif` might be evaluated after the promotion and can encounter a promoted.
  50     const ALLOW_PROMOTED: bool = false;
  51
  52     /// Extracts the field of `ConstQualifs` that corresponds to this `Qualif`.
  53     fn in_qualifs(qualifs: &ConstQualifs) -> bool;
  54
  55     /// Returns `true` if *any* value of the given type could possibly have this `Qualif`.
  56     ///
  57     /// This function determines `Qualif`s when we cannot do a value-based analysis. Since qualif
  58     /// propagation is context-insensitive, this includes function arguments and values returned
  59     /// from a call to another function.
  60     ///
  61     /// It also determines the `Qualif`s for primitive types.
  62     fn in_any_value_of_ty<'tcx>(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool;
  63
  64     /// Returns `true` if this `Qualif` is inherent to the given struct or enum.
  65     ///
  66     /// By default, `Qualif`s propagate into ADTs in a structural way: An ADT only becomes
  67     /// qualified if part of it is assigned a value with that `Qualif`. However, some ADTs *always*
  68     /// have a certain `Qualif`, regardless of whether their fields have it. For example, a type
  69     /// with a custom `Drop` impl is inherently `NeedsDrop`.
  70     ///
  71     /// Returning `true` for `in_adt_inherently` but `false` for `in_any_value_of_ty` is unsound.
  72     fn in_adt_inherently<'tcx>(
  73         cx: &ConstCx<'_, 'tcx>,
  74         adt: AdtDef<'tcx>,
  75         substs: SubstsRef<'tcx>,
  76     ) -> bool;
  77 }
  78
  79 /// Constant containing interior mutability (`UnsafeCell<T>`).
  80 /// This must be ruled out to make sure that evaluating the constant at compile-time
  81 /// and at *any point* during the run-time would produce the same result. In particular,
  82 /// promotion of temporaries must not change program behavior; if the promoted could be
  83 /// written to, that would be a problem.
  84 pub struct HasMutInterior;
  85
  86 impl Qualif for HasMutInterior {
  87     const ANALYSIS_NAME: &'static str = "flow_has_mut_interior";
  88
  89     fn in_qualifs(qualifs: &ConstQualifs) -> bool {
  90         qualifs.has_mut_interior
  91     }
  92
  93     fn in_any_value_of_ty<'tcx>(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool {
  94         !ty.is_freeze(cx.tcx, cx.param_env)
  95     }
  96
  97     fn in_adt_inherently<'tcx>(
  98         _cx: &ConstCx<'_, 'tcx>,
  99         adt: AdtDef<'tcx>,
 100         _: SubstsRef<'tcx>,
 101     ) -> bool {
 102         // Exactly one type, `UnsafeCell`, has the `HasMutInterior` qualif inherently.
 103         // It arises structurally for all other types.
 104         adt.is_unsafe_cell()
 105     }
 106 }
 107
 108 /// Constant containing an ADT that implements `Drop`.
 109 /// This must be ruled out because implicit promotion would remove side-effects
 110 /// that occur as part of dropping that value. N.B., the implicit promotion has
 111 /// to reject const Drop implementations because even if side-effects are ruled
 112 /// out through other means, the execution of the drop could diverge.
 113 pub struct NeedsDrop;
 114
 115 impl Qualif for NeedsDrop {
 116     const ANALYSIS_NAME: &'static str = "flow_needs_drop";
 117     const IS_CLEARED_ON_MOVE: bool = true;
 118
 119     fn in_qualifs(qualifs: &ConstQualifs) -> bool {
 120         qualifs.needs_drop
 121     }
 122
 123     fn in_any_value_of_ty<'tcx>(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool {
 124         ty.needs_drop(cx.tcx, cx.param_env)
 125     }
 126
 127     fn in_adt_inherently<'tcx>(
 128         cx: &ConstCx<'_, 'tcx>,
 129         adt: AdtDef<'tcx>,
 130         _: SubstsRef<'tcx>,
 131     ) -> bool {
 132         adt.has_dtor(cx.tcx)
 133     }
 134 }
 135
 136 /// Constant containing an ADT that implements non-const `Drop`.
 137 /// This must be ruled out because we cannot run `Drop` during compile-time.
 138 pub struct NeedsNonConstDrop;
 139
 140 impl Qualif for NeedsNonConstDrop {
 141     const ANALYSIS_NAME: &'static str = "flow_needs_nonconst_drop";
 142     const IS_CLEARED_ON_MOVE: bool = true;
 143     const ALLOW_PROMOTED: bool = true;
 144
 145     fn in_qualifs(qualifs: &ConstQualifs) -> bool {
 146         qualifs.needs_non_const_drop
 147     }
 148
 149     fn in_any_value_of_ty<'tcx>(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool {
 150         // Avoid selecting for simple cases, such as builtin types.
 151         if ty::util::is_trivially_const_drop(ty) {
 152             return false;
 153         }
 154
 155         let destruct = cx.tcx.require_lang_item(LangItem::Destruct, None);
 156
 157         let obligation = Obligation::new(
 158             ObligationCause::dummy(),
 159             cx.param_env,
 160             ty::Binder::dummy(ty::TraitPredicate {
 161                 trait_ref: ty::TraitRef {
 162                     def_id: destruct,
 163                     substs: cx.tcx.mk_substs_trait(ty, &[]),
 164                 },
 165                 constness: ty::BoundConstness::ConstIfConst,
 166                 polarity: ty::ImplPolarity::Positive,
 167             }),
 168         );
 169
 170         let infcx = cx.tcx.infer_ctxt().build();
 171         let mut selcx = SelectionContext::new(&infcx);
 172         let Some(impl_src) = selcx.select(&obligation).ok().flatten() else {
 173             // If we couldn't select a const destruct candidate, then it's bad
 174             return true;
 175         };
 176
 177         if !matches!(
 178             impl_src,
 179             ImplSource::ConstDestruct(_) | ImplSource::Param(_, ty::BoundConstness::ConstIfConst)
 180         ) {
 181             // If our const destruct candidate is not ConstDestruct or implied by the param env,
 182             // then it's bad
 183             return true;
 184         }
 185
 186         if impl_src.borrow_nested_obligations().is_empty() {
 187             return false;
 188         }
 189
 190         // If we had any errors, then it's bad
 191         !traits::fully_solve_obligations(&infcx, impl_src.nested_obligations()).is_empty()
 192     }
 193
 194     fn in_adt_inherently<'tcx>(
 195         cx: &ConstCx<'_, 'tcx>,
 196         adt: AdtDef<'tcx>,
 197         _: SubstsRef<'tcx>,
 198     ) -> bool {
 199         adt.has_non_const_dtor(cx.tcx)
 200     }
 201 }
 202
 203 /// A constant that cannot be used as part of a pattern in a `match` expression.
 204 pub struct CustomEq;
 205
 206 impl Qualif for CustomEq {
 207     const ANALYSIS_NAME: &'static str = "flow_custom_eq";
 208
 209     fn in_qualifs(qualifs: &ConstQualifs) -> bool {
 210         qualifs.custom_eq
 211     }
 212
 213     fn in_any_value_of_ty<'tcx>(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool {
 214         // If *any* component of a composite data type does not implement `Structural{Partial,}Eq`,
 215         // we know that at least some values of that type are not structural-match. I say "some"
 216         // because that component may be part of an enum variant (e.g.,
 217         // `Option::<NonStructuralMatchTy>::Some`), in which case some values of this type may be
 218         // structural-match (`Option::None`).
 219         traits::search_for_structural_match_violation(cx.body.span, cx.tcx, ty).is_some()
 220     }
 221
 222     fn in_adt_inherently<'tcx>(
 223         cx: &ConstCx<'_, 'tcx>,
 224         adt: AdtDef<'tcx>,
 225         substs: SubstsRef<'tcx>,
 226     ) -> bool {
 227         let ty = cx.tcx.mk_ty(ty::Adt(adt, substs));
 228         !ty.is_structural_eq_shallow(cx.tcx)
 229     }
 230 }
 231
 232 // FIXME: Use `mir::visit::Visitor` for the `in_*` functions if/when it supports early return.
 233
 234 /// Returns `true` if this `Rvalue` contains qualif `Q`.
 235 pub fn in_rvalue<'tcx, Q, F>(
 236     cx: &ConstCx<'_, 'tcx>,
 237     in_local: &mut F,
 238     rvalue: &Rvalue<'tcx>,
 239 ) -> bool
 240 where
 241     Q: Qualif,
 242     F: FnMut(Local) -> bool,
 243 {
 244     match rvalue {
 245         Rvalue::ThreadLocalRef(_) | Rvalue::NullaryOp(..) => {
 246             Q::in_any_value_of_ty(cx, rvalue.ty(cx.body, cx.tcx))
 247         }
 248
 249         Rvalue::Discriminant(place) | Rvalue::Len(place) => {
 250             in_place::<Q, _>(cx, in_local, place.as_ref())
 251         }
 252
 253         Rvalue::CopyForDeref(place) => in_place::<Q, _>(cx, in_local, place.as_ref()),
 254
 255         Rvalue::Use(operand)
 256         | Rvalue::Repeat(operand, _)
 257         | Rvalue::UnaryOp(_, operand)
 258         | Rvalue::Cast(_, operand, _)
 259         | Rvalue::ShallowInitBox(operand, _) => in_operand::<Q, _>(cx, in_local, operand),
 260
 261         Rvalue::BinaryOp(_, box (lhs, rhs)) | Rvalue::CheckedBinaryOp(_, box (lhs, rhs)) => {
 262             in_operand::<Q, _>(cx, in_local, lhs) || in_operand::<Q, _>(cx, in_local, rhs)
 263         }
 264
 265         Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
 266             // Special-case reborrows to be more like a copy of the reference.
 267             if let Some((place_base, ProjectionElem::Deref)) = place.as_ref().last_projection() {
 268                 let base_ty = place_base.ty(cx.body, cx.tcx).ty;
 269                 if let ty::Ref(..) = base_ty.kind() {
 270                     return in_place::<Q, _>(cx, in_local, place_base);
 271                 }
 272             }
 273
 274             in_place::<Q, _>(cx, in_local, place.as_ref())
 275         }
 276
 277         Rvalue::Aggregate(kind, operands) => {
 278             // Return early if we know that the struct or enum being constructed is always
 279             // qualified.
 280             if let AggregateKind::Adt(adt_did, _, substs, ..) = **kind {
 281                 let def = cx.tcx.adt_def(adt_did);
 282                 if Q::in_adt_inherently(cx, def, substs) {
 283                     return true;
 284                 }
 285                 if def.is_union() && Q::in_any_value_of_ty(cx, rvalue.ty(cx.body, cx.tcx)) {
 286                     return true;
 287                 }
 288             }
 289
 290             // Otherwise, proceed structurally...
 291             operands.iter().any(|o| in_operand::<Q, _>(cx, in_local, o))
 292         }
 293     }
 294 }
 295
 296 /// Returns `true` if this `Place` contains qualif `Q`.
 297 pub fn in_place<'tcx, Q, F>(cx: &ConstCx<'_, 'tcx>, in_local: &mut F, place: PlaceRef<'tcx>) -> bool
 298 where
 299     Q: Qualif,
 300     F: FnMut(Local) -> bool,
 301 {
 302     let mut place = place;
 303     while let Some((place_base, elem)) = place.last_projection() {
 304         match elem {
 305             ProjectionElem::Index(index) if in_local(index) => return true,
 306
 307             ProjectionElem::Deref
 308             | ProjectionElem::Field(_, _)
 309             | ProjectionElem::OpaqueCast(_)
 310             | ProjectionElem::ConstantIndex { .. }
 311             | ProjectionElem::Subslice { .. }
 312             | ProjectionElem::Downcast(_, _)
 313             | ProjectionElem::Index(_) => {}
 314         }
 315
 316         let base_ty = place_base.ty(cx.body, cx.tcx);
 317         let proj_ty = base_ty.projection_ty(cx.tcx, elem).ty;
 318         if !Q::in_any_value_of_ty(cx, proj_ty) {
 319             return false;
 320         }
 321
 322         place = place_base;
 323     }
 324
 325     assert!(place.projection.is_empty());
 326     in_local(place.local)
 327 }
 328
 329 /// Returns `true` if this `Operand` contains qualif `Q`.
 330 pub fn in_operand<'tcx, Q, F>(
 331     cx: &ConstCx<'_, 'tcx>,
 332     in_local: &mut F,
 333     operand: &Operand<'tcx>,
 334 ) -> bool
 335 where
 336     Q: Qualif,
 337     F: FnMut(Local) -> bool,
 338 {
 339     let constant = match operand {
 340         Operand::Copy(place) | Operand::Move(place) => {
 341             return in_place::<Q, _>(cx, in_local, place.as_ref());
 342         }
 343
 344         Operand::Constant(c) => c,
 345     };
 346
 347     // Check the qualifs of the value of `const` items.
 348     // FIXME(valtrees): check whether const qualifs should behave the same
 349     // way for type and mir constants.
 350     let uneval = match constant.literal {
 351         ConstantKind::Ty(ct) if matches!(ct.kind(), ty::ConstKind::Param(_)) => None,
 352         ConstantKind::Ty(c) => bug!("expected ConstKind::Param here, found {:?}", c),
 353         ConstantKind::Unevaluated(uv, _) => Some(uv),
 354         ConstantKind::Val(..) => None,
 355     };
 356
 357     if let Some(mir::UnevaluatedConst { def, substs: _, promoted }) = uneval {
 358         // Use qualifs of the type for the promoted. Promoteds in MIR body should be possible
 359         // only for `NeedsNonConstDrop` with precise drop checking. This is the only const
 360         // check performed after the promotion. Verify that with an assertion.
 361         assert!(promoted.is_none() || Q::ALLOW_PROMOTED);
 362
 363         // Don't peek inside trait associated constants.
 364         if promoted.is_none() && cx.tcx.trait_of_item(def.did).is_none() {
 365             assert_eq!(def.const_param_did, None, "expected associated const: {def:?}");
 366             let qualifs = cx.tcx.at(constant.span).mir_const_qualif(def.did);
 367
 368             if !Q::in_qualifs(&qualifs) {
 369                 return false;
 370             }
 371
 372             // Just in case the type is more specific than
 373             // the definition, e.g., impl associated const
 374             // with type parameters, take it into account.
 375         }
 376     }
 377
 378     // Otherwise use the qualifs of the type.
 379     Q::in_any_value_of_ty(cx, constant.literal.ty())
 380 }