1 //! Values computed by queries that use MIR.
3 use crate::mir::{Body, ConstantKind, Promoted};
4 use crate::ty::{self, OpaqueHiddenType, Ty, TyCtxt};
5 use rustc_data_structures::fx::FxHashSet;
6 use rustc_data_structures::vec_map::VecMap;
7 use rustc_errors::ErrorGuaranteed;
9 use rustc_hir::def_id::{DefId, LocalDefId};
10 use rustc_index::bit_set::BitMatrix;
11 use rustc_index::vec::IndexVec;
13 use rustc_target::abi::VariantIdx;
14 use smallvec::SmallVec;
16 use std::fmt::{self, Debug};
18 use super::{Field, SourceInfo};
20 #[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable, Debug)]
21 pub enum UnsafetyViolationKind {
22 /// Unsafe operation outside `unsafe`.
24 /// Unsafe operation in an `unsafe fn` but outside an `unsafe` block.
25 /// Has to be handled as a lint for backwards compatibility.
29 #[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable, Debug)]
30 pub enum UnsafetyViolationDetails {
39 MutationOfLayoutConstrainedField,
40 BorrowOfLayoutConstrainedField,
44 impl UnsafetyViolationDetails {
45 pub fn description_and_note(&self) -> (&'static str, &'static str) {
46 use UnsafetyViolationDetails::*;
48 CallToUnsafeFunction => (
49 "call to unsafe function",
50 "consult the function's documentation for information on how to avoid undefined \
53 UseOfInlineAssembly => (
54 "use of inline assembly",
55 "inline assembly is entirely unchecked and can cause undefined behavior",
57 InitializingTypeWith => (
58 "initializing type with `rustc_layout_scalar_valid_range` attr",
59 "initializing a layout restricted type's field with a value outside the valid \
60 range is undefined behavior",
62 CastOfPointerToInt => {
63 ("cast of pointer to int", "casting pointers to integers in constants")
65 UseOfMutableStatic => (
66 "use of mutable static",
67 "mutable statics can be mutated by multiple threads: aliasing violations or data \
68 races will cause undefined behavior",
70 UseOfExternStatic => (
71 "use of extern static",
72 "extern statics are not controlled by the Rust type system: invalid data, \
73 aliasing violations or data races will cause undefined behavior",
75 DerefOfRawPointer => (
76 "dereference of raw pointer",
77 "raw pointers may be null, dangling or unaligned; they can violate aliasing rules \
78 and cause data races: all of these are undefined behavior",
80 AccessToUnionField => (
81 "access to union field",
82 "the field may not be properly initialized: using uninitialized data will cause \
85 MutationOfLayoutConstrainedField => (
86 "mutation of layout constrained field",
87 "mutating layout constrained fields cannot statically be checked for valid values",
89 BorrowOfLayoutConstrainedField => (
90 "borrow of layout constrained field with interior mutability",
91 "references to fields of layout constrained fields lose the constraints. Coupled \
92 with interior mutability, the field can be changed to invalid values",
94 CallToFunctionWith => (
95 "call to function with `#[target_feature]`",
96 "can only be called if the required target features are available",
102 #[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable, Debug)]
103 pub struct UnsafetyViolation {
104 pub source_info: SourceInfo,
105 pub lint_root: hir::HirId,
106 pub kind: UnsafetyViolationKind,
107 pub details: UnsafetyViolationDetails,
110 #[derive(Copy, Clone, PartialEq, TyEncodable, TyDecodable, HashStable, Debug)]
111 pub enum UnusedUnsafe {
112 /// `unsafe` block contains no unsafe operations
113 /// > ``unnecessary `unsafe` block``
115 /// `unsafe` block nested under another (used) `unsafe` block
116 /// > ``… because it's nested under this `unsafe` block``
117 InUnsafeBlock(hir::HirId),
120 #[derive(TyEncodable, TyDecodable, HashStable, Debug)]
121 pub struct UnsafetyCheckResult {
122 /// Violations that are propagated *upwards* from this function.
123 pub violations: Vec<UnsafetyViolation>,
125 /// Used `unsafe` blocks in this function. This is used for the "unused_unsafe" lint.
126 pub used_unsafe_blocks: FxHashSet<hir::HirId>,
128 /// This is `Some` iff the item is not a closure.
129 pub unused_unsafes: Option<Vec<(hir::HirId, UnusedUnsafe)>>,
132 rustc_index::newtype_index! {
133 pub struct GeneratorSavedLocal {
135 DEBUG_FORMAT = "_{}",
139 /// The layout of generator state.
140 #[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
141 pub struct GeneratorLayout<'tcx> {
142 /// The type of every local stored inside the generator.
143 pub field_tys: IndexVec<GeneratorSavedLocal, Ty<'tcx>>,
145 /// Which of the above fields are in each variant. Note that one field may
146 /// be stored in multiple variants.
147 pub variant_fields: IndexVec<VariantIdx, IndexVec<Field, GeneratorSavedLocal>>,
149 /// The source that led to each variant being created (usually, a yield or
151 pub variant_source_info: IndexVec<VariantIdx, SourceInfo>,
153 /// Which saved locals are storage-live at the same time. Locals that do not
154 /// have conflicts with each other are allowed to overlap in the computed
156 pub storage_conflicts: BitMatrix<GeneratorSavedLocal, GeneratorSavedLocal>,
159 impl Debug for GeneratorLayout<'_> {
160 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
161 /// Prints an iterator of (key, value) tuples as a map.
162 struct MapPrinter<'a, K, V>(Cell<Option<Box<dyn Iterator<Item = (K, V)> + 'a>>>);
163 impl<'a, K, V> MapPrinter<'a, K, V> {
164 fn new(iter: impl Iterator<Item = (K, V)> + 'a) -> Self {
165 Self(Cell::new(Some(Box::new(iter))))
168 impl<'a, K: Debug, V: Debug> Debug for MapPrinter<'a, K, V> {
169 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
170 fmt.debug_map().entries(self.0.take().unwrap()).finish()
174 /// Prints the generator variant name.
175 struct GenVariantPrinter(VariantIdx);
176 impl From<VariantIdx> for GenVariantPrinter {
177 fn from(idx: VariantIdx) -> Self {
178 GenVariantPrinter(idx)
181 impl Debug for GenVariantPrinter {
182 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
183 let variant_name = ty::GeneratorSubsts::variant_name(self.0);
185 write!(fmt, "{:9}({:?})", variant_name, self.0)
187 write!(fmt, "{}", variant_name)
192 /// Forces its contents to print in regular mode instead of alternate mode.
193 struct OneLinePrinter<T>(T);
194 impl<T: Debug> Debug for OneLinePrinter<T> {
195 fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
196 write!(fmt, "{:?}", self.0)
200 fmt.debug_struct("GeneratorLayout")
201 .field("field_tys", &MapPrinter::new(self.field_tys.iter_enumerated()))
207 .map(|(k, v)| (GenVariantPrinter(k), OneLinePrinter(v))),
210 .field("storage_conflicts", &self.storage_conflicts)
215 #[derive(Debug, TyEncodable, TyDecodable, HashStable)]
216 pub struct BorrowCheckResult<'tcx> {
217 /// All the opaque types that are restricted to concrete types
218 /// by this function. Unlike the value in `TypeckResults`, this has
219 /// unerased regions.
220 pub concrete_opaque_types: VecMap<LocalDefId, OpaqueHiddenType<'tcx>>,
221 pub closure_requirements: Option<ClosureRegionRequirements<'tcx>>,
222 pub used_mut_upvars: SmallVec<[Field; 8]>,
223 pub tainted_by_errors: Option<ErrorGuaranteed>,
226 /// The result of the `mir_const_qualif` query.
228 /// Each field (except `error_occurred`) corresponds to an implementer of the `Qualif` trait in
229 /// `rustc_const_eval/src/transform/check_consts/qualifs.rs`. See that file for more information on each
231 #[derive(Clone, Copy, Debug, Default, TyEncodable, TyDecodable, HashStable)]
232 pub struct ConstQualifs {
233 pub has_mut_interior: bool,
234 pub needs_drop: bool,
235 pub needs_non_const_drop: bool,
237 pub tainted_by_errors: Option<ErrorGuaranteed>,
240 /// After we borrow check a closure, we are left with various
241 /// requirements that we have inferred between the free regions that
242 /// appear in the closure's signature or on its field types. These
243 /// requirements are then verified and proved by the closure's
244 /// creating function. This struct encodes those requirements.
246 /// The requirements are listed as being between various `RegionVid`. The 0th
247 /// region refers to `'static`; subsequent region vids refer to the free
248 /// regions that appear in the closure (or generator's) type, in order of
249 /// appearance. (This numbering is actually defined by the `UniversalRegions`
250 /// struct in the NLL region checker. See for example
251 /// `UniversalRegions::closure_mapping`.) Note the free regions in the
252 /// closure's signature and captures are erased.
254 /// Example: If type check produces a closure with the closure substs:
257 /// ClosureSubsts = [
258 /// 'a, // From the parent.
260 /// i8, // the "closure kind"
261 /// for<'x> fn(&'<erased> &'x u32) -> &'x u32, // the "closure signature"
262 /// &'<erased> String, // some upvar
266 /// We would "renumber" each free region to a unique vid, as follows:
269 /// ClosureSubsts = [
270 /// '1, // From the parent.
272 /// i8, // the "closure kind"
273 /// for<'x> fn(&'3 &'x u32) -> &'x u32, // the "closure signature"
274 /// &'4 String, // some upvar
278 /// Now the code might impose a requirement like `'1: '2`. When an
279 /// instance of the closure is created, the corresponding free regions
280 /// can be extracted from its type and constrained to have the given
281 /// outlives relationship.
283 /// In some cases, we have to record outlives requirements between types and
284 /// regions as well. In that case, if those types include any regions, those
285 /// regions are recorded using their external names (`ReStatic`,
286 /// `ReEarlyBound`, `ReFree`). We use these because in a query response we
287 /// cannot use `ReVar` (which is what we use internally within the rest of the
289 #[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable)]
290 pub struct ClosureRegionRequirements<'tcx> {
291 /// The number of external regions defined on the closure. In our
292 /// example above, it would be 3 -- one for `'static`, then `'1`
293 /// and `'2`. This is just used for a sanity check later on, to
294 /// make sure that the number of regions we see at the callsite
296 pub num_external_vids: usize,
298 /// Requirements between the various free regions defined in
300 pub outlives_requirements: Vec<ClosureOutlivesRequirement<'tcx>>,
303 /// Indicates an outlives-constraint between a type or between two
304 /// free regions declared on the closure.
305 #[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)]
306 pub struct ClosureOutlivesRequirement<'tcx> {
307 // This region or type ...
308 pub subject: ClosureOutlivesSubject<'tcx>,
310 // ... must outlive this one.
311 pub outlived_free_region: ty::RegionVid,
313 // If not, report an error here ...
314 pub blame_span: Span,
316 // ... due to this reason.
317 pub category: ConstraintCategory<'tcx>,
320 // Make sure this enum doesn't unintentionally grow
321 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
322 rustc_data_structures::static_assert_size!(ConstraintCategory<'_>, 16);
324 /// Outlives-constraints can be categorized to determine whether and why they
325 /// are interesting (for error reporting). Order of variants indicates sort
326 /// order of the category, thereby influencing diagnostic output.
328 /// See also `rustc_const_eval::borrow_check::constraints`.
329 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
330 #[derive(TyEncodable, TyDecodable, HashStable, Lift, TypeVisitable, TypeFoldable)]
331 pub enum ConstraintCategory<'tcx> {
332 Return(ReturnConstraint),
339 /// A constraint that came from checking the body of a closure.
341 /// We try to get the category that the closure used when reporting this.
344 /// Contains the function type if available.
345 CallArgument(Option<Ty<'tcx>>),
349 /// A constraint that came from a usage of a variable (e.g. in an ADT expression
350 /// like `Foo { field: my_val }`)
355 /// A constraint from a user-written predicate
356 /// with the provided span, written on the item
357 /// with the given `DefId`
360 /// A "boring" constraint (caused by the given location) is one that
361 /// the user probably doesn't want to see described in diagnostics,
362 /// because it is kind of an artifact of the type system setup.
364 // Boring and applicable everywhere.
367 /// A constraint that doesn't correspond to anything the user sees.
371 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
372 #[derive(TyEncodable, TyDecodable, HashStable, TypeVisitable, TypeFoldable)]
373 pub enum ReturnConstraint {
378 /// The subject of a `ClosureOutlivesRequirement` -- that is, the thing
379 /// that must outlive some region.
380 #[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable)]
381 pub enum ClosureOutlivesSubject<'tcx> {
382 /// Subject is a type, typically a type parameter, but could also
383 /// be a projection. Indicates a requirement like `T: 'a` being
384 /// passed to the caller, where the type here is `T`.
386 /// The type here is guaranteed not to contain any free regions at
390 /// Subject is a free region from the closure. Indicates a requirement
391 /// like `'a: 'b` being passed to the caller; the region here is `'a`.
392 Region(ty::RegionVid),
395 /// The constituent parts of a mir constant of kind ADT or array.
396 #[derive(Copy, Clone, Debug, HashStable)]
397 pub struct DestructuredConstant<'tcx> {
398 pub variant: Option<VariantIdx>,
399 pub fields: &'tcx [ConstantKind<'tcx>],
402 /// Coverage information summarized from a MIR if instrumented for source code coverage (see
403 /// compiler option `-Cinstrument-coverage`). This information is generated by the
404 /// `InstrumentCoverage` MIR pass and can be retrieved via the `coverageinfo` query.
405 #[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable)]
406 pub struct CoverageInfo {
407 /// The total number of coverage region counters added to the MIR `Body`.
408 pub num_counters: u32,
410 /// The total number of coverage region counter expressions added to the MIR `Body`.
411 pub num_expressions: u32,
414 /// Shims which make dealing with `WithOptConstParam` easier.
416 /// For more information on why this is needed, consider looking
417 /// at the docs for `WithOptConstParam` itself.
418 impl<'tcx> TyCtxt<'tcx> {
420 pub fn mir_const_qualif_opt_const_arg(
422 def: ty::WithOptConstParam<LocalDefId>,
424 if let Some(param_did) = def.const_param_did {
425 self.mir_const_qualif_const_arg((def.did, param_did))
427 self.mir_const_qualif(def.did)
432 pub fn promoted_mir_opt_const_arg(
434 def: ty::WithOptConstParam<DefId>,
435 ) -> &'tcx IndexVec<Promoted, Body<'tcx>> {
436 if let Some((did, param_did)) = def.as_const_arg() {
437 self.promoted_mir_of_const_arg((did, param_did))
439 self.promoted_mir(def.did)
444 pub fn mir_for_ctfe_opt_const_arg(self, def: ty::WithOptConstParam<DefId>) -> &'tcx Body<'tcx> {
445 if let Some((did, param_did)) = def.as_const_arg() {
446 self.mir_for_ctfe_of_const_arg((did, param_did))
448 self.mir_for_ctfe(def.did)