1 // ignore-tidy-filelength
3 //! MIR datatypes and passes. See the [rustc guide] for more info.
5 //! [rustc guide]: https://rust-lang.github.io/rustc-guide/mir/index.html
7 use crate::hir
::def
::{CtorKind, Namespace}
;
8 use crate::hir
::def_id
::DefId
;
9 use crate::hir
::{self, GeneratorKind}
;
10 use crate::mir
::interpret
::{GlobalAlloc, PanicInfo, Scalar}
;
11 use crate::mir
::visit
::MirVisitable
;
12 use crate::ty
::adjustment
::PointerCast
;
13 use crate::ty
::fold
::{TypeFoldable, TypeFolder, TypeVisitor}
;
14 use crate::ty
::layout
::VariantIdx
;
15 use crate::ty
::print
::{FmtPrinter, Printer}
;
16 use crate::ty
::subst
::{Subst, SubstsRef}
;
18 self, AdtDef
, CanonicalUserTypeAnnotations
, List
, Region
, Ty
, TyCtxt
, UserTypeAnnotationIndex
,
21 use polonius_engine
::Atom
;
22 use rustc_index
::bit_set
::BitMatrix
;
23 use rustc_data_structures
::fx
::FxHashSet
;
24 use rustc_data_structures
::graph
::dominators
::Dominators
;
25 use rustc_data_structures
::graph
::{self, GraphSuccessors}
;
26 use rustc_index
::vec
::{Idx, IndexVec}
;
27 use rustc_data_structures
::sync
::Lrc
;
28 use rustc_macros
::HashStable
;
29 use rustc_serialize
::{Encodable, Decodable}
;
30 use smallvec
::SmallVec
;
32 use std
::fmt
::{self, Debug, Display, Formatter, Write}
;
35 use std
::{iter, mem, option, u32}
;
36 use syntax
::ast
::Name
;
37 use syntax
::symbol
::Symbol
;
38 use syntax_pos
::{Span, DUMMY_SP}
;
40 pub use crate::mir
::interpret
::AssertMessage
;
41 pub use crate::mir
::cache
::{BodyAndCache, ReadOnlyBodyAndCache}
;
42 pub use crate::read_only
;
52 type LocalDecls
<'tcx
> = IndexVec
<Local
, LocalDecl
<'tcx
>>;
54 pub trait HasLocalDecls
<'tcx
> {
55 fn local_decls(&self) -> &LocalDecls
<'tcx
>;
58 impl<'tcx
> HasLocalDecls
<'tcx
> for LocalDecls
<'tcx
> {
59 fn local_decls(&self) -> &LocalDecls
<'tcx
> {
64 impl<'tcx
> HasLocalDecls
<'tcx
> for Body
<'tcx
> {
65 fn local_decls(&self) -> &LocalDecls
<'tcx
> {
70 /// The various "big phases" that MIR goes through.
72 /// Warning: ordering of variants is significant.
73 #[derive(Copy, Clone, RustcEncodable, RustcDecodable, HashStable,
74 Debug
, PartialEq
, Eq
, PartialOrd
, Ord
)]
83 /// Gets the index of the current MirPhase within the set of all `MirPhase`s.
84 pub fn phase_index(&self) -> usize {
89 /// The lowered representation of a single function.
90 #[derive(Clone, RustcEncodable, RustcDecodable, Debug, HashStable, TypeFoldable)]
91 pub struct Body
<'tcx
> {
92 /// A list of basic blocks. References to basic block use a newtyped index type `BasicBlock`
93 /// that indexes into this vector.
94 basic_blocks
: IndexVec
<BasicBlock
, BasicBlockData
<'tcx
>>,
96 /// Records how far through the "desugaring and optimization" process this particular
97 /// MIR has traversed. This is particularly useful when inlining, since in that context
98 /// we instantiate the promoted constants and add them to our promoted vector -- but those
99 /// promoted items have already been optimized, whereas ours have not. This field allows
100 /// us to see the difference and forego optimization on the inlined promoted items.
103 /// A list of source scopes; these are referenced by statements
104 /// and used for debuginfo. Indexed by a `SourceScope`.
105 pub source_scopes
: IndexVec
<SourceScope
, SourceScopeData
>,
107 /// The yield type of the function, if it is a generator.
108 pub yield_ty
: Option
<Ty
<'tcx
>>,
110 /// Generator drop glue.
111 pub generator_drop
: Option
<Box
<BodyAndCache
<'tcx
>>>,
113 /// The layout of a generator. Produced by the state transformation.
114 pub generator_layout
: Option
<GeneratorLayout
<'tcx
>>,
116 /// If this is a generator then record the type of source expression that caused this generator
118 pub generator_kind
: Option
<GeneratorKind
>,
120 /// Declarations of locals.
122 /// The first local is the return value pointer, followed by `arg_count`
123 /// locals for the function arguments, followed by any user-declared
124 /// variables and temporaries.
125 pub local_decls
: LocalDecls
<'tcx
>,
127 /// User type annotations.
128 pub user_type_annotations
: CanonicalUserTypeAnnotations
<'tcx
>,
130 /// The number of arguments this function takes.
132 /// Starting at local 1, `arg_count` locals will be provided by the caller
133 /// and can be assumed to be initialized.
135 /// If this MIR was built for a constant, this will be 0.
136 pub arg_count
: usize,
138 /// Mark an argument local (which must be a tuple) as getting passed as
139 /// its individual components at the LLVM level.
141 /// This is used for the "rust-call" ABI.
142 pub spread_arg
: Option
<Local
>,
144 /// Debug information pertaining to user variables, including captures.
145 pub var_debug_info
: Vec
<VarDebugInfo
<'tcx
>>,
147 /// Mark this MIR of a const context other than const functions as having converted a `&&` or
148 /// `||` expression into `&` or `|` respectively. This is problematic because if we ever stop
149 /// this conversion from happening and use short circuiting, we will cause the following code
150 /// to change the value of `x`: `let mut x = 42; false && { x = 55; true };`
152 /// List of places where control flow was destroyed. Used for error reporting.
153 pub control_flow_destroyed
: Vec
<(Span
, String
)>,
155 /// A span representing this MIR, for error reporting.
159 impl<'tcx
> Body
<'tcx
> {
161 basic_blocks
: IndexVec
<BasicBlock
, BasicBlockData
<'tcx
>>,
162 source_scopes
: IndexVec
<SourceScope
, SourceScopeData
>,
163 local_decls
: LocalDecls
<'tcx
>,
164 user_type_annotations
: CanonicalUserTypeAnnotations
<'tcx
>,
166 var_debug_info
: Vec
<VarDebugInfo
<'tcx
>>,
168 control_flow_destroyed
: Vec
<(Span
, String
)>,
169 generator_kind
: Option
<GeneratorKind
>,
171 // We need `arg_count` locals, and one for the return place.
173 local_decls
.len() >= arg_count
+ 1,
174 "expected at least {} locals, got {}",
180 phase
: MirPhase
::Build
,
184 generator_drop
: None
,
185 generator_layout
: None
,
188 user_type_annotations
,
193 control_flow_destroyed
,
198 pub fn basic_blocks(&self) -> &IndexVec
<BasicBlock
, BasicBlockData
<'tcx
>> {
202 /// Returns `true` if a cycle exists in the control-flow graph that is reachable from the
204 pub fn is_cfg_cyclic(&self) -> bool
{
205 graph
::is_cyclic(self)
209 pub fn local_kind(&self, local
: Local
) -> LocalKind
{
210 let index
= local
.as_usize();
213 self.local_decls
[local
].mutability
== Mutability
::Mut
,
214 "return place should be mutable"
217 LocalKind
::ReturnPointer
218 } else if index
< self.arg_count
+ 1 {
220 } else if self.local_decls
[local
].is_user_variable() {
227 /// Returns an iterator over all temporaries.
229 pub fn temps_iter
<'a
>(&'a
self) -> impl Iterator
<Item
= Local
> + 'a
{
230 (self.arg_count
+ 1..self.local_decls
.len()).filter_map(move |index
| {
231 let local
= Local
::new(index
);
232 if self.local_decls
[local
].is_user_variable() {
240 /// Returns an iterator over all user-declared locals.
242 pub fn vars_iter
<'a
>(&'a
self) -> impl Iterator
<Item
= Local
> + 'a
{
243 (self.arg_count
+ 1..self.local_decls
.len()).filter_map(move |index
| {
244 let local
= Local
::new(index
);
245 self.local_decls
[local
].is_user_variable().then_some(local
)
249 /// Returns an iterator over all user-declared mutable locals.
251 pub fn mut_vars_iter
<'a
>(&'a
self) -> impl Iterator
<Item
= Local
> + 'a
{
252 (self.arg_count
+ 1..self.local_decls
.len()).filter_map(move |index
| {
253 let local
= Local
::new(index
);
254 let decl
= &self.local_decls
[local
];
255 if decl
.is_user_variable() && decl
.mutability
== Mutability
::Mut
{
263 /// Returns an iterator over all user-declared mutable arguments and locals.
265 pub fn mut_vars_and_args_iter
<'a
>(&'a
self) -> impl Iterator
<Item
= Local
> + 'a
{
266 (1..self.local_decls
.len()).filter_map(move |index
| {
267 let local
= Local
::new(index
);
268 let decl
= &self.local_decls
[local
];
269 if (decl
.is_user_variable() || index
< self.arg_count
+ 1)
270 && decl
.mutability
== Mutability
::Mut
279 /// Returns an iterator over all function arguments.
281 pub fn args_iter(&self) -> impl Iterator
<Item
= Local
> + ExactSizeIterator
{
282 let arg_count
= self.arg_count
;
283 (1..arg_count
+ 1).map(Local
::new
)
286 /// Returns an iterator over all user-defined variables and compiler-generated temporaries (all
287 /// locals that are neither arguments nor the return place).
289 pub fn vars_and_temps_iter(&self) -> impl Iterator
<Item
= Local
> + ExactSizeIterator
{
290 let arg_count
= self.arg_count
;
291 let local_count
= self.local_decls
.len();
292 (arg_count
+ 1..local_count
).map(Local
::new
)
295 /// Changes a statement to a nop. This is both faster than deleting instructions and avoids
296 /// invalidating statement indices in `Location`s.
297 pub fn make_statement_nop(&mut self, location
: Location
) {
298 let block
= &mut self.basic_blocks
[location
.block
];
299 debug_assert
!(location
.statement_index
< block
.statements
.len());
300 block
.statements
[location
.statement_index
].make_nop()
303 /// Returns the source info associated with `location`.
304 pub fn source_info(&self, location
: Location
) -> &SourceInfo
{
305 let block
= &self[location
.block
];
306 let stmts
= &block
.statements
;
307 let idx
= location
.statement_index
;
308 if idx
< stmts
.len() {
309 &stmts
[idx
].source_info
311 assert_eq
!(idx
, stmts
.len());
312 &block
.terminator().source_info
316 /// Checks if `sub` is a sub scope of `sup`
317 pub fn is_sub_scope(&self, mut sub
: SourceScope
, sup
: SourceScope
) -> bool
{
319 match self.source_scopes
[sub
].parent_scope
{
320 None
=> return false,
327 /// Returns the return type; it always return first element from `local_decls` array.
328 pub fn return_ty(&self) -> Ty
<'tcx
> {
329 self.local_decls
[RETURN_PLACE
].ty
332 /// Gets the location of the terminator for the given block.
333 pub fn terminator_loc(&self, bb
: BasicBlock
) -> Location
{
334 Location { block: bb, statement_index: self[bb].statements.len() }
338 #[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
341 /// Unsafe because of a PushUnsafeBlock
343 /// Unsafe because of an unsafe fn
345 /// Unsafe because of an `unsafe` block
346 ExplicitUnsafe(hir
::HirId
),
349 impl<'tcx
> Index
<BasicBlock
> for Body
<'tcx
> {
350 type Output
= BasicBlockData
<'tcx
>;
353 fn index(&self, index
: BasicBlock
) -> &BasicBlockData
<'tcx
> {
354 &self.basic_blocks()[index
]
358 #[derive(Copy, Clone, Debug, HashStable, TypeFoldable)]
359 pub enum ClearCrossCrate
<T
> {
364 impl<T
> ClearCrossCrate
<T
> {
365 pub fn as_ref(&'a
self) -> ClearCrossCrate
<&'a T
> {
367 ClearCrossCrate
::Clear
=> ClearCrossCrate
::Clear
,
368 ClearCrossCrate
::Set(v
) => ClearCrossCrate
::Set(v
),
372 pub fn assert_crate_local(self) -> T
{
374 ClearCrossCrate
::Clear
=> bug
!("unwrapping cross-crate data"),
375 ClearCrossCrate
::Set(v
) => v
,
380 impl<T
: Encodable
> rustc_serialize
::UseSpecializedEncodable
for ClearCrossCrate
<T
> {}
381 impl<T
: Decodable
> rustc_serialize
::UseSpecializedDecodable
for ClearCrossCrate
<T
> {}
383 /// Grouped information about the source code origin of a MIR entity.
384 /// Intended to be inspected by diagnostics and debuginfo.
385 /// Most passes can work with it as a whole, within a single function.
386 // The unofficial Cranelift backend, at least as of #65828, needs `SourceInfo` to implement `Eq` and
387 // `Hash`. Please ping @bjorn3 if removing them.
388 #[derive(Copy, Clone, Debug, Eq, PartialEq, RustcEncodable, RustcDecodable, Hash, HashStable)]
389 pub struct SourceInfo
{
390 /// The source span for the AST pertaining to this MIR entity.
393 /// The source scope, keeping track of which bindings can be
394 /// seen by debuginfo, active lint levels, `unsafe {...}`, etc.
395 pub scope
: SourceScope
,
398 ///////////////////////////////////////////////////////////////////////////
399 // Mutability and borrow kinds
401 #[derive(Copy, Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)]
402 pub enum Mutability
{
407 impl From
<Mutability
> for hir
::Mutability
{
408 fn from(m
: Mutability
) -> Self {
410 Mutability
::Mut
=> hir
::Mutability
::Mutable
,
411 Mutability
::Not
=> hir
::Mutability
::Immutable
,
417 Copy
, Clone
, Debug
, PartialEq
, Eq
, PartialOrd
, Ord
, RustcEncodable
, RustcDecodable
, HashStable
,
419 pub enum BorrowKind
{
420 /// Data must be immutable and is aliasable.
423 /// The immediately borrowed place must be immutable, but projections from
424 /// it don't need to be. For example, a shallow borrow of `a.b` doesn't
425 /// conflict with a mutable borrow of `a.b.c`.
427 /// This is used when lowering matches: when matching on a place we want to
428 /// ensure that place have the same value from the start of the match until
429 /// an arm is selected. This prevents this code from compiling:
431 /// let mut x = &Some(0);
434 /// Some(_) if { x = &None; false } => (),
438 /// This can't be a shared borrow because mutably borrowing (*x as Some).0
439 /// should not prevent `if let None = x { ... }`, for example, because the
440 /// mutating `(*x as Some).0` can't affect the discriminant of `x`.
441 /// We can also report errors with this kind of borrow differently.
444 /// Data must be immutable but not aliasable. This kind of borrow
445 /// cannot currently be expressed by the user and is used only in
446 /// implicit closure bindings. It is needed when the closure is
447 /// borrowing or mutating a mutable referent, e.g.:
449 /// let x: &mut isize = ...;
450 /// let y = || *x += 5;
452 /// If we were to try to translate this closure into a more explicit
453 /// form, we'd encounter an error with the code as written:
455 /// struct Env { x: & &mut isize }
456 /// let x: &mut isize = ...;
457 /// let y = (&mut Env { &x }, fn_ptr); // Closure is pair of env and fn
458 /// fn fn_ptr(env: &mut Env) { **env.x += 5; }
460 /// This is then illegal because you cannot mutate an `&mut` found
461 /// in an aliasable location. To solve, you'd have to translate with
462 /// an `&mut` borrow:
464 /// struct Env { x: & &mut isize }
465 /// let x: &mut isize = ...;
466 /// let y = (&mut Env { &mut x }, fn_ptr); // changed from &x to &mut x
467 /// fn fn_ptr(env: &mut Env) { **env.x += 5; }
469 /// Now the assignment to `**env.x` is legal, but creating a
470 /// mutable pointer to `x` is not because `x` is not mutable. We
471 /// could fix this by declaring `x` as `let mut x`. This is ok in
472 /// user code, if awkward, but extra weird for closures, since the
473 /// borrow is hidden.
475 /// So we introduce a "unique imm" borrow -- the referent is
476 /// immutable, but not aliasable. This solves the problem. For
477 /// simplicity, we don't give users the way to express this
478 /// borrow, it's just used when translating closures.
481 /// Data is mutable and not aliasable.
483 /// `true` if this borrow arose from method-call auto-ref
484 /// (i.e., `adjustment::Adjust::Borrow`).
485 allow_two_phase_borrow
: bool
,
490 pub fn allows_two_phase_borrow(&self) -> bool
{
492 BorrowKind
::Shared
| BorrowKind
::Shallow
| BorrowKind
::Unique
=> false,
493 BorrowKind
::Mut { allow_two_phase_borrow }
=> allow_two_phase_borrow
,
498 ///////////////////////////////////////////////////////////////////////////
499 // Variables and temps
501 rustc_index
::newtype_index
! {
504 DEBUG_FORMAT
= "_{}",
505 const RETURN_PLACE
= 0,
509 impl Atom
for Local
{
510 fn index(self) -> usize {
515 /// Classifies locals into categories. See `Body::local_kind`.
516 #[derive(PartialEq, Eq, Debug, HashStable)]
518 /// User-declared variable binding.
520 /// Compiler-introduced temporary.
522 /// Function argument.
524 /// Location of function's return value.
528 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
529 pub struct VarBindingForm
<'tcx
> {
530 /// Is variable bound via `x`, `mut x`, `ref x`, or `ref mut x`?
531 pub binding_mode
: ty
::BindingMode
,
532 /// If an explicit type was provided for this variable binding,
533 /// this holds the source Span of that type.
535 /// NOTE: if you want to change this to a `HirId`, be wary that
536 /// doing so breaks incremental compilation (as of this writing),
537 /// while a `Span` does not cause our tests to fail.
538 pub opt_ty_info
: Option
<Span
>,
539 /// Place of the RHS of the =, or the subject of the `match` where this
540 /// variable is initialized. None in the case of `let PATTERN;`.
541 /// Some((None, ..)) in the case of and `let [mut] x = ...` because
542 /// (a) the right-hand side isn't evaluated as a place expression.
543 /// (b) it gives a way to separate this case from the remaining cases
545 pub opt_match_place
: Option
<(Option
<Place
<'tcx
>>, Span
)>,
546 /// The span of the pattern in which this variable was bound.
550 #[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
551 pub enum BindingForm
<'tcx
> {
552 /// This is a binding for a non-`self` binding, or a `self` that has an explicit type.
553 Var(VarBindingForm
<'tcx
>),
554 /// Binding for a `self`/`&self`/`&mut self` binding where the type is implicit.
555 ImplicitSelf(ImplicitSelfKind
),
556 /// Reference used in a guard expression to ensure immutability.
560 /// Represents what type of implicit self a function has, if any.
561 #[derive(Clone, Copy, PartialEq, Debug, RustcEncodable, RustcDecodable, HashStable)]
562 pub enum ImplicitSelfKind
{
563 /// Represents a `fn x(self);`.
565 /// Represents a `fn x(mut self);`.
567 /// Represents a `fn x(&self);`.
569 /// Represents a `fn x(&mut self);`.
571 /// Represents when a function does not have a self argument or
572 /// when a function has a `self: X` argument.
576 CloneTypeFoldableAndLiftImpls
! { BindingForm<'tcx>, }
578 mod binding_form_impl
{
579 use crate::ich
::StableHashingContext
;
580 use rustc_data_structures
::stable_hasher
::{HashStable, StableHasher}
;
582 impl<'a
, 'tcx
> HashStable
<StableHashingContext
<'a
>> for super::BindingForm
<'tcx
> {
583 fn hash_stable(&self, hcx
: &mut StableHashingContext
<'a
>, hasher
: &mut StableHasher
) {
584 use super::BindingForm
::*;
585 ::std
::mem
::discriminant(self).hash_stable(hcx
, hasher
);
588 Var(binding
) => binding
.hash_stable(hcx
, hasher
),
589 ImplicitSelf(kind
) => kind
.hash_stable(hcx
, hasher
),
596 /// `BlockTailInfo` is attached to the `LocalDecl` for temporaries
597 /// created during evaluation of expressions in a block tail
598 /// expression; that is, a block like `{ STMT_1; STMT_2; EXPR }`.
600 /// It is used to improve diagnostics when such temporaries are
601 /// involved in borrow_check errors, e.g., explanations of where the
602 /// temporaries come from, when their destructors are run, and/or how
603 /// one might revise the code to satisfy the borrow checker's rules.
604 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
605 pub struct BlockTailInfo
{
606 /// If `true`, then the value resulting from evaluating this tail
607 /// expression is ignored by the block's expression context.
609 /// Examples include `{ ...; tail };` and `let _ = { ...; tail };`
610 /// but not e.g., `let _x = { ...; tail };`
611 pub tail_result_is_ignored
: bool
,
616 /// This can be a binding declared by the user, a temporary inserted by the compiler, a function
617 /// argument, or the return place.
618 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
619 pub struct LocalDecl
<'tcx
> {
620 /// Whether this is a mutable minding (i.e., `let x` or `let mut x`).
622 /// Temporaries and the return place are always mutable.
623 pub mutability
: Mutability
,
625 // FIXME(matthewjasper) Don't store in this in `Body`
626 pub local_info
: LocalInfo
<'tcx
>,
628 /// `true` if this is an internal local.
630 /// These locals are not based on types in the source code and are only used
631 /// for a few desugarings at the moment.
633 /// The generator transformation will sanity check the locals which are live
634 /// across a suspension point against the type components of the generator
635 /// which type checking knows are live across a suspension point. We need to
636 /// flag drop flags to avoid triggering this check as they are introduced
639 /// Unsafety checking will also ignore dereferences of these locals,
640 /// so they can be used for raw pointers only used in a desugaring.
642 /// This should be sound because the drop flags are fully algebraic, and
643 /// therefore don't affect the OIBIT or outlives properties of the
647 /// If this local is a temporary and `is_block_tail` is `Some`,
648 /// then it is a temporary created for evaluation of some
649 /// subexpression of some block's tail expression (with no
650 /// intervening statement context).
651 // FIXME(matthewjasper) Don't store in this in `Body`
652 pub is_block_tail
: Option
<BlockTailInfo
>,
654 /// The type of this local.
657 /// If the user manually ascribed a type to this variable,
658 /// e.g., via `let x: T`, then we carry that type here. The MIR
659 /// borrow checker needs this information since it can affect
660 /// region inference.
661 // FIXME(matthewjasper) Don't store in this in `Body`
662 pub user_ty
: UserTypeProjections
,
664 /// The *syntactic* (i.e., not visibility) source scope the local is defined
665 /// in. If the local was defined in a let-statement, this
666 /// is *within* the let-statement, rather than outside
669 /// This is needed because the visibility source scope of locals within
670 /// a let-statement is weird.
672 /// The reason is that we want the local to be *within* the let-statement
673 /// for lint purposes, but we want the local to be *after* the let-statement
674 /// for names-in-scope purposes.
676 /// That's it, if we have a let-statement like the one in this
680 /// fn foo(x: &str) {
681 /// #[allow(unused_mut)]
682 /// let mut x: u32 = { // <- one unused mut
683 /// let mut y: u32 = x.parse().unwrap();
690 /// Then, from a lint point of view, the declaration of `x: u32`
691 /// (and `y: u32`) are within the `#[allow(unused_mut)]` scope - the
692 /// lint scopes are the same as the AST/HIR nesting.
694 /// However, from a name lookup point of view, the scopes look more like
695 /// as if the let-statements were `match` expressions:
698 /// fn foo(x: &str) {
700 /// match x.parse().unwrap() {
709 /// We care about the name-lookup scopes for debuginfo - if the
710 /// debuginfo instruction pointer is at the call to `x.parse()`, we
711 /// want `x` to refer to `x: &str`, but if it is at the call to
712 /// `drop(x)`, we want it to refer to `x: u32`.
714 /// To allow both uses to work, we need to have more than a single scope
715 /// for a local. We have the `source_info.scope` represent the "syntactic"
716 /// lint scope (with a variable being under its let block) while the
717 /// `var_debug_info.source_info.scope` represents the "local variable"
718 /// scope (where the "rest" of a block is under all prior let-statements).
720 /// The end result looks like this:
724 /// │{ argument x: &str }
726 /// │ │{ #[allow(unused_mut)] } // This is actually split into 2 scopes
727 /// │ │ // in practice because I'm lazy.
729 /// │ │← x.source_info.scope
730 /// │ │← `x.parse().unwrap()`
732 /// │ │ │← y.source_info.scope
734 /// │ │ │{ let y: u32 }
736 /// │ │ │← y.var_debug_info.source_info.scope
739 /// │ │{ let x: u32 }
740 /// │ │← x.var_debug_info.source_info.scope
741 /// │ │← `drop(x)` // This accesses `x: u32`.
743 pub source_info
: SourceInfo
,
746 /// Extra information about a local that's used for diagnostics.
747 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
748 pub enum LocalInfo
<'tcx
> {
749 /// A user-defined local variable or function parameter
751 /// The `BindingForm` is solely used for local diagnostics when generating
752 /// warnings/errors when compiling the current crate, and therefore it need
753 /// not be visible across crates.
754 User(ClearCrossCrate
<BindingForm
<'tcx
>>),
755 /// A temporary created that references the static with the given `DefId`.
756 StaticRef { def_id: DefId, is_thread_local: bool }
,
757 /// Any other temporary, the return place, or an anonymous function parameter.
761 impl<'tcx
> LocalDecl
<'tcx
> {
762 /// Returns `true` only if local is a binding that can itself be
763 /// made mutable via the addition of the `mut` keyword, namely
764 /// something like the occurrences of `x` in:
765 /// - `fn foo(x: Type) { ... }`,
767 /// - or `match ... { C(x) => ... }`
768 pub fn can_be_made_mutable(&self) -> bool
{
769 match self.local_info
{
770 LocalInfo
::User(ClearCrossCrate
::Set(BindingForm
::Var(VarBindingForm
{
771 binding_mode
: ty
::BindingMode
::BindByValue(_
),
778 ClearCrossCrate
::Set(BindingForm
::ImplicitSelf(ImplicitSelfKind
::Imm
)),
785 /// Returns `true` if local is definitely not a `ref ident` or
786 /// `ref mut ident` binding. (Such bindings cannot be made into
787 /// mutable bindings, but the inverse does not necessarily hold).
788 pub fn is_nonref_binding(&self) -> bool
{
789 match self.local_info
{
790 LocalInfo
::User(ClearCrossCrate
::Set(BindingForm
::Var(VarBindingForm
{
791 binding_mode
: ty
::BindingMode
::BindByValue(_
),
797 LocalInfo
::User(ClearCrossCrate
::Set(BindingForm
::ImplicitSelf(_
))) => true,
803 /// Returns `true` if this variable is a named variable or function
804 /// parameter declared by the user.
806 pub fn is_user_variable(&self) -> bool
{
807 match self.local_info
{
808 LocalInfo
::User(_
) => true,
813 /// Returns `true` if this is a reference to a variable bound in a `match`
814 /// expression that is used to access said variable for the guard of the
816 pub fn is_ref_for_guard(&self) -> bool
{
817 match self.local_info
{
818 LocalInfo
::User(ClearCrossCrate
::Set(BindingForm
::RefForGuard
)) => true,
823 /// Returns `Some` if this is a reference to a static item that is used to
824 /// access that static
825 pub fn is_ref_to_static(&self) -> bool
{
826 match self.local_info
{
827 LocalInfo
::StaticRef { .. }
=> true,
832 /// Returns `Some` if this is a reference to a static item that is used to
833 /// access that static
834 pub fn is_ref_to_thread_local(&self) -> bool
{
835 match self.local_info
{
836 LocalInfo
::StaticRef { is_thread_local, .. }
=> is_thread_local
,
841 /// Returns `true` is the local is from a compiler desugaring, e.g.,
842 /// `__next` from a `for` loop.
844 pub fn from_compiler_desugaring(&self) -> bool
{
845 self.source_info
.span
.desugaring_kind().is_some()
848 /// Creates a new `LocalDecl` for a temporary.
850 pub fn new_temp(ty
: Ty
<'tcx
>, span
: Span
) -> Self {
851 Self::new_local(ty
, Mutability
::Mut
, false, span
)
854 /// Converts `self` into same `LocalDecl` except tagged as immutable.
856 pub fn immutable(mut self) -> Self {
857 self.mutability
= Mutability
::Not
;
861 /// Converts `self` into same `LocalDecl` except tagged as internal temporary.
863 pub fn block_tail(mut self, info
: BlockTailInfo
) -> Self {
864 assert
!(self.is_block_tail
.is_none());
865 self.is_block_tail
= Some(info
);
869 /// Creates a new `LocalDecl` for a internal temporary.
871 pub fn new_internal(ty
: Ty
<'tcx
>, span
: Span
) -> Self {
872 Self::new_local(ty
, Mutability
::Mut
, true, span
)
876 fn new_local(ty
: Ty
<'tcx
>, mutability
: Mutability
, internal
: bool
, span
: Span
) -> Self {
880 user_ty
: UserTypeProjections
::none(),
881 source_info
: SourceInfo { span, scope: OUTERMOST_SOURCE_SCOPE }
,
883 local_info
: LocalInfo
::Other
,
888 /// Builds a `LocalDecl` for the return place.
890 /// This must be inserted into the `local_decls` list as the first local.
892 pub fn new_return_place(return_ty
: Ty
<'_
>, span
: Span
) -> LocalDecl
<'_
> {
894 mutability
: Mutability
::Mut
,
896 user_ty
: UserTypeProjections
::none(),
897 source_info
: SourceInfo { span, scope: OUTERMOST_SOURCE_SCOPE }
,
900 local_info
: LocalInfo
::Other
,
905 /// Debug information pertaining to a user variable.
906 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
907 pub struct VarDebugInfo
<'tcx
> {
910 /// Source info of the user variable, including the scope
911 /// within which the variable is visible (to debuginfo)
912 /// (see `LocalDecl`'s `source_info` field for more details).
913 pub source_info
: SourceInfo
,
915 /// Where the data for this user variable is to be found.
916 /// NOTE(eddyb) There's an unenforced invariant that this `Place` is
917 /// based on a `Local`, not a `Static`, and contains no indexing.
918 pub place
: Place
<'tcx
>,
921 ///////////////////////////////////////////////////////////////////////////
924 rustc_index
::newtype_index
! {
925 pub struct BasicBlock
{
927 DEBUG_FORMAT
= "bb{}",
928 const START_BLOCK
= 0,
933 pub fn start_location(self) -> Location
{
934 Location { block: self, statement_index: 0 }
938 ///////////////////////////////////////////////////////////////////////////
939 // BasicBlockData and Terminator
941 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
942 pub struct BasicBlockData
<'tcx
> {
943 /// List of statements in this block.
944 pub statements
: Vec
<Statement
<'tcx
>>,
946 /// Terminator for this block.
948 /// N.B., this should generally ONLY be `None` during construction.
949 /// Therefore, you should generally access it via the
950 /// `terminator()` or `terminator_mut()` methods. The only
951 /// exception is that certain passes, such as `simplify_cfg`, swap
952 /// out the terminator temporarily with `None` while they continue
953 /// to recurse over the set of basic blocks.
954 pub terminator
: Option
<Terminator
<'tcx
>>,
956 /// If true, this block lies on an unwind path. This is used
957 /// during codegen where distinct kinds of basic blocks may be
958 /// generated (particularly for MSVC cleanup). Unwind blocks must
959 /// only branch to other unwind blocks.
960 pub is_cleanup
: bool
,
963 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
964 pub struct Terminator
<'tcx
> {
965 pub source_info
: SourceInfo
,
966 pub kind
: TerminatorKind
<'tcx
>,
969 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable, PartialEq)]
970 pub enum TerminatorKind
<'tcx
> {
971 /// Block should have one successor in the graph; we jump there.
972 Goto { target: BasicBlock }
,
974 /// Operand evaluates to an integer; jump depending on its value
975 /// to one of the targets, and otherwise fallback to `otherwise`.
977 /// The discriminant value being tested.
978 discr
: Operand
<'tcx
>,
980 /// The type of value being tested.
983 /// Possible values. The locations to branch to in each case
984 /// are found in the corresponding indices from the `targets` vector.
985 values
: Cow
<'tcx
, [u128
]>,
987 /// Possible branch sites. The last element of this vector is used
988 /// for the otherwise branch, so targets.len() == values.len() + 1
991 // This invariant is quite non-obvious and also could be improved.
992 // One way to make this invariant is to have something like this instead:
994 // branches: Vec<(ConstInt, BasicBlock)>,
995 // otherwise: Option<BasicBlock> // exhaustive if None
997 // However we’ve decided to keep this as-is until we figure a case
998 // where some other approach seems to be strictly better than other.
999 targets
: Vec
<BasicBlock
>,
1002 /// Indicates that the landing pad is finished and unwinding should
1003 /// continue. Emitted by `build::scope::diverge_cleanup`.
1006 /// Indicates that the landing pad is finished and that the process
1007 /// should abort. Used to prevent unwinding for foreign items.
1010 /// Indicates a normal return. The return place should have
1011 /// been filled in by now. This should occur at most once.
1014 /// Indicates a terminator that can never be reached.
1017 /// Drop the `Place`.
1018 Drop { location: Place<'tcx>, target: BasicBlock, unwind: Option<BasicBlock> }
,
1020 /// Drop the `Place` and assign the new value over it. This ensures
1021 /// that the assignment to `P` occurs *even if* the destructor for
1022 /// place unwinds. Its semantics are best explained by the
1027 /// DropAndReplace(P <- V, goto BB1, unwind BB2)
1035 /// Drop(P, goto BB1, unwind BB2)
1038 /// // P is now uninitialized
1042 /// // P is now uninitialized -- its dtor panicked
1047 location
: Place
<'tcx
>,
1048 value
: Operand
<'tcx
>,
1050 unwind
: Option
<BasicBlock
>,
1053 /// Block ends with a call of a converging function.
1055 /// The function that’s being called.
1056 func
: Operand
<'tcx
>,
1057 /// Arguments the function is called with.
1058 /// These are owned by the callee, which is free to modify them.
1059 /// This allows the memory occupied by "by-value" arguments to be
1060 /// reused across function calls without duplicating the contents.
1061 args
: Vec
<Operand
<'tcx
>>,
1062 /// Destination for the return value. If some, the call is converging.
1063 destination
: Option
<(Place
<'tcx
>, BasicBlock
)>,
1064 /// Cleanups to be done if the call unwinds.
1065 cleanup
: Option
<BasicBlock
>,
1066 /// `true` if this is from a call in HIR rather than from an overloaded
1067 /// operator. True for overloaded function call.
1068 from_hir_call
: bool
,
1071 /// Jump to the target if the condition has the expected value,
1072 /// otherwise panic with a message and a cleanup target.
1074 cond
: Operand
<'tcx
>,
1076 msg
: AssertMessage
<'tcx
>,
1078 cleanup
: Option
<BasicBlock
>,
1081 /// A suspend point.
1083 /// The value to return.
1084 value
: Operand
<'tcx
>,
1085 /// Where to resume to.
1087 /// Cleanup to be done if the generator is dropped at this suspend point.
1088 drop
: Option
<BasicBlock
>,
1091 /// Indicates the end of the dropping of a generator.
1094 /// A block where control flow only ever takes one real path, but borrowck
1095 /// needs to be more conservative.
1097 /// The target normal control flow will take.
1098 real_target
: BasicBlock
,
1099 /// A block control flow could conceptually jump to, but won't in
1101 imaginary_target
: BasicBlock
,
1103 /// A terminator for blocks that only take one path in reality, but where we
1104 /// reserve the right to unwind in borrowck, even if it won't happen in practice.
1105 /// This can arise in infinite loops with no function calls for example.
1107 /// The target normal control flow will take.
1108 real_target
: BasicBlock
,
1109 /// The imaginary cleanup block link. This particular path will never be taken
1110 /// in practice, but in order to avoid fragility we want to always
1111 /// consider it in borrowck. We don't want to accept programs which
1112 /// pass borrowck only when `panic=abort` or some assertions are disabled
1113 /// due to release vs. debug mode builds. This needs to be an `Option` because
1114 /// of the `remove_noop_landing_pads` and `no_landing_pads` passes.
1115 unwind
: Option
<BasicBlock
>,
1119 pub type Successors
<'a
> =
1120 iter
::Chain
<option
::IntoIter
<&'a BasicBlock
>, slice
::Iter
<'a
, BasicBlock
>>;
1121 pub type SuccessorsMut
<'a
> =
1122 iter
::Chain
<option
::IntoIter
<&'a
mut BasicBlock
>, slice
::IterMut
<'a
, BasicBlock
>>;
1124 impl<'tcx
> Terminator
<'tcx
> {
1125 pub fn successors(&self) -> Successors
<'_
> {
1126 self.kind
.successors()
1129 pub fn successors_mut(&mut self) -> SuccessorsMut
<'_
> {
1130 self.kind
.successors_mut()
1133 pub fn unwind(&self) -> Option
<&Option
<BasicBlock
>> {
1137 pub fn unwind_mut(&mut self) -> Option
<&mut Option
<BasicBlock
>> {
1138 self.kind
.unwind_mut()
1142 impl<'tcx
> TerminatorKind
<'tcx
> {
1145 cond
: Operand
<'tcx
>,
1148 ) -> TerminatorKind
<'tcx
> {
1149 static BOOL_SWITCH_FALSE
: &'
static [u128
] = &[0];
1150 TerminatorKind
::SwitchInt
{
1152 switch_ty
: tcx
.types
.bool
,
1153 values
: From
::from(BOOL_SWITCH_FALSE
),
1154 targets
: vec
![f
, t
],
1158 pub fn successors(&self) -> Successors
<'_
> {
1159 use self::TerminatorKind
::*;
1166 | Call { destination: None, cleanup: None, .. }
=> None
.into_iter().chain(&[]),
1167 Goto { target: ref t }
1168 | Call { destination: None, cleanup: Some(ref t), .. }
1169 | Call { destination: Some((_, ref t)), cleanup: None, .. }
1170 | Yield { resume: ref t, drop: None, .. }
1171 | DropAndReplace { target: ref t, unwind: None, .. }
1172 | Drop { target: ref t, unwind: None, .. }
1173 | Assert { target: ref t, cleanup: None, .. }
1174 | FalseUnwind { real_target: ref t, unwind: None }
=> Some(t
).into_iter().chain(&[]),
1175 Call { destination: Some((_, ref t)), cleanup: Some(ref u), .. }
1176 | Yield { resume: ref t, drop: Some(ref u), .. }
1177 | DropAndReplace { target: ref t, unwind: Some(ref u), .. }
1178 | Drop { target: ref t, unwind: Some(ref u), .. }
1179 | Assert { target: ref t, cleanup: Some(ref u), .. }
1180 | FalseUnwind { real_target: ref t, unwind: Some(ref u) }
=> {
1181 Some(t
).into_iter().chain(slice
::from_ref(u
))
1183 SwitchInt { ref targets, .. }
=> None
.into_iter().chain(&targets
[..]),
1184 FalseEdges { ref real_target, ref imaginary_target }
=> {
1185 Some(real_target
).into_iter().chain(slice
::from_ref(imaginary_target
))
1190 pub fn successors_mut(&mut self) -> SuccessorsMut
<'_
> {
1191 use self::TerminatorKind
::*;
1198 | Call { destination: None, cleanup: None, .. }
=> None
.into_iter().chain(&mut []),
1199 Goto { target: ref mut t }
1200 | Call { destination: None, cleanup: Some(ref mut t), .. }
1201 | Call { destination: Some((_, ref mut t)), cleanup: None, .. }
1202 | Yield { resume: ref mut t, drop: None, .. }
1203 | DropAndReplace { target: ref mut t, unwind: None, .. }
1204 | Drop { target: ref mut t, unwind: None, .. }
1205 | Assert { target: ref mut t, cleanup: None, .. }
1206 | FalseUnwind { real_target: ref mut t, unwind: None }
=> {
1207 Some(t
).into_iter().chain(&mut [])
1209 Call { destination: Some((_, ref mut t)), cleanup: Some(ref mut u), .. }
1210 | Yield { resume: ref mut t, drop: Some(ref mut u), .. }
1211 | DropAndReplace { target: ref mut t, unwind: Some(ref mut u), .. }
1212 | Drop { target: ref mut t, unwind: Some(ref mut u), .. }
1213 | Assert { target: ref mut t, cleanup: Some(ref mut u), .. }
1214 | FalseUnwind { real_target: ref mut t, unwind: Some(ref mut u) }
=> {
1215 Some(t
).into_iter().chain(slice
::from_mut(u
))
1217 SwitchInt { ref mut targets, .. }
=> None
.into_iter().chain(&mut targets
[..]),
1218 FalseEdges { ref mut real_target, ref mut imaginary_target }
=> {
1219 Some(real_target
).into_iter().chain(slice
::from_mut(imaginary_target
))
1224 pub fn unwind(&self) -> Option
<&Option
<BasicBlock
>> {
1226 TerminatorKind
::Goto { .. }
1227 | TerminatorKind
::Resume
1228 | TerminatorKind
::Abort
1229 | TerminatorKind
::Return
1230 | TerminatorKind
::Unreachable
1231 | TerminatorKind
::GeneratorDrop
1232 | TerminatorKind
::Yield { .. }
1233 | TerminatorKind
::SwitchInt { .. }
1234 | TerminatorKind
::FalseEdges { .. }
=> None
,
1235 TerminatorKind
::Call { cleanup: ref unwind, .. }
1236 | TerminatorKind
::Assert { cleanup: ref unwind, .. }
1237 | TerminatorKind
::DropAndReplace { ref unwind, .. }
1238 | TerminatorKind
::Drop { ref unwind, .. }
1239 | TerminatorKind
::FalseUnwind { ref unwind, .. }
=> Some(unwind
),
1243 pub fn unwind_mut(&mut self) -> Option
<&mut Option
<BasicBlock
>> {
1245 TerminatorKind
::Goto { .. }
1246 | TerminatorKind
::Resume
1247 | TerminatorKind
::Abort
1248 | TerminatorKind
::Return
1249 | TerminatorKind
::Unreachable
1250 | TerminatorKind
::GeneratorDrop
1251 | TerminatorKind
::Yield { .. }
1252 | TerminatorKind
::SwitchInt { .. }
1253 | TerminatorKind
::FalseEdges { .. }
=> None
,
1254 TerminatorKind
::Call { cleanup: ref mut unwind, .. }
1255 | TerminatorKind
::Assert { cleanup: ref mut unwind, .. }
1256 | TerminatorKind
::DropAndReplace { ref mut unwind, .. }
1257 | TerminatorKind
::Drop { ref mut unwind, .. }
1258 | TerminatorKind
::FalseUnwind { ref mut unwind, .. }
=> Some(unwind
),
1263 impl<'tcx
> BasicBlockData
<'tcx
> {
1264 pub fn new(terminator
: Option
<Terminator
<'tcx
>>) -> BasicBlockData
<'tcx
> {
1265 BasicBlockData { statements: vec![], terminator, is_cleanup: false }
1268 /// Accessor for terminator.
1270 /// Terminator may not be None after construction of the basic block is complete. This accessor
1271 /// provides a convenience way to reach the terminator.
1272 pub fn terminator(&self) -> &Terminator
<'tcx
> {
1273 self.terminator
.as_ref().expect("invalid terminator state")
1276 pub fn terminator_mut(&mut self) -> &mut Terminator
<'tcx
> {
1277 self.terminator
.as_mut().expect("invalid terminator state")
1280 pub fn retain_statements
<F
>(&mut self, mut f
: F
)
1282 F
: FnMut(&mut Statement
<'_
>) -> bool
,
1284 for s
in &mut self.statements
{
1291 pub fn expand_statements
<F
, I
>(&mut self, mut f
: F
)
1293 F
: FnMut(&mut Statement
<'tcx
>) -> Option
<I
>,
1294 I
: iter
::TrustedLen
<Item
= Statement
<'tcx
>>,
1296 // Gather all the iterators we'll need to splice in, and their positions.
1297 let mut splices
: Vec
<(usize, I
)> = vec
![];
1298 let mut extra_stmts
= 0;
1299 for (i
, s
) in self.statements
.iter_mut().enumerate() {
1300 if let Some(mut new_stmts
) = f(s
) {
1301 if let Some(first
) = new_stmts
.next() {
1302 // We can already store the first new statement.
1305 // Save the other statements for optimized splicing.
1306 let remaining
= new_stmts
.size_hint().0;
1308 splices
.push((i
+ 1 + extra_stmts
, new_stmts
));
1309 extra_stmts
+= remaining
;
1317 // Splice in the new statements, from the end of the block.
1318 // FIXME(eddyb) This could be more efficient with a "gap buffer"
1319 // where a range of elements ("gap") is left uninitialized, with
1320 // splicing adding new elements to the end of that gap and moving
1321 // existing elements from before the gap to the end of the gap.
1322 // For now, this is safe code, emulating a gap but initializing it.
1323 let mut gap
= self.statements
.len()..self.statements
.len() + extra_stmts
;
1324 self.statements
.resize(
1327 source_info
: SourceInfo { span: DUMMY_SP, scope: OUTERMOST_SOURCE_SCOPE }
,
1328 kind
: StatementKind
::Nop
,
1331 for (splice_start
, new_stmts
) in splices
.into_iter().rev() {
1332 let splice_end
= splice_start
+ new_stmts
.size_hint().0;
1333 while gap
.end
> splice_end
{
1336 self.statements
.swap(gap
.start
, gap
.end
);
1338 self.statements
.splice(splice_start
..splice_end
, new_stmts
);
1339 gap
.end
= splice_start
;
1343 pub fn visitable(&self, index
: usize) -> &dyn MirVisitable
<'tcx
> {
1344 if index
< self.statements
.len() {
1345 &self.statements
[index
]
1352 impl<'tcx
> Debug
for TerminatorKind
<'tcx
> {
1353 fn fmt(&self, fmt
: &mut Formatter
<'_
>) -> fmt
::Result
{
1354 self.fmt_head(fmt
)?
;
1355 let successor_count
= self.successors().count();
1356 let labels
= self.fmt_successor_labels();
1357 assert_eq
!(successor_count
, labels
.len());
1359 match successor_count
{
1362 1 => write
!(fmt
, " -> {:?}", self.successors().nth(0).unwrap()),
1365 write
!(fmt
, " -> [")?
;
1366 for (i
, target
) in self.successors().enumerate() {
1370 write
!(fmt
, "{}: {:?}", labels
[i
], target
)?
;
1378 impl<'tcx
> TerminatorKind
<'tcx
> {
1379 /// Writes the "head" part of the terminator; that is, its name and the data it uses to pick the
1380 /// successor basic block, if any. The only information not included is the list of possible
1381 /// successors, which may be rendered differently between the text and the graphviz format.
1382 pub fn fmt_head
<W
: Write
>(&self, fmt
: &mut W
) -> fmt
::Result
{
1383 use self::TerminatorKind
::*;
1385 Goto { .. }
=> write
!(fmt
, "goto"),
1386 SwitchInt { discr: ref place, .. }
=> write
!(fmt
, "switchInt({:?})", place
),
1387 Return
=> write
!(fmt
, "return"),
1388 GeneratorDrop
=> write
!(fmt
, "generator_drop"),
1389 Resume
=> write
!(fmt
, "resume"),
1390 Abort
=> write
!(fmt
, "abort"),
1391 Yield { ref value, .. }
=> write
!(fmt
, "_1 = suspend({:?})", value
),
1392 Unreachable
=> write
!(fmt
, "unreachable"),
1393 Drop { ref location, .. }
=> write
!(fmt
, "drop({:?})", location
),
1394 DropAndReplace { ref location, ref value, .. }
=> {
1395 write
!(fmt
, "replace({:?} <- {:?})", location
, value
)
1397 Call { ref func, ref args, ref destination, .. }
=> {
1398 if let Some((ref destination
, _
)) = *destination
{
1399 write
!(fmt
, "{:?} = ", destination
)?
;
1401 write
!(fmt
, "{:?}(", func
)?
;
1402 for (index
, arg
) in args
.iter().enumerate() {
1406 write
!(fmt
, "{:?}", arg
)?
;
1410 Assert { ref cond, expected, ref msg, .. }
=> {
1411 write
!(fmt
, "assert(")?
;
1415 write
!(fmt
, "{:?}, \"{:?}\")", cond
, msg
)
1417 FalseEdges { .. }
=> write
!(fmt
, "falseEdges"),
1418 FalseUnwind { .. }
=> write
!(fmt
, "falseUnwind"),
1422 /// Returns the list of labels for the edges to the successor basic blocks.
1423 pub fn fmt_successor_labels(&self) -> Vec
<Cow
<'
static, str>> {
1424 use self::TerminatorKind
::*;
1426 Return
| Resume
| Abort
| Unreachable
| GeneratorDrop
=> vec
![],
1427 Goto { .. }
=> vec
!["".into()],
1428 SwitchInt { ref values, switch_ty, .. }
=> ty
::tls
::with(|tcx
| {
1429 let param_env
= ty
::ParamEnv
::empty();
1430 let switch_ty
= tcx
.lift(&switch_ty
).unwrap();
1431 let size
= tcx
.layout_of(param_env
.and(switch_ty
)).unwrap().size
;
1435 ty
::Const
::from_scalar(
1437 Scalar
::from_uint(u
, size
).into(),
1443 .chain(iter
::once("otherwise".into()))
1446 Call { destination: Some(_), cleanup: Some(_), .. }
=> {
1447 vec
!["return".into(), "unwind".into()]
1449 Call { destination: Some(_), cleanup: None, .. }
=> vec
!["return".into()],
1450 Call { destination: None, cleanup: Some(_), .. }
=> vec
!["unwind".into()],
1451 Call { destination: None, cleanup: None, .. }
=> vec
![],
1452 Yield { drop: Some(_), .. }
=> vec
!["resume".into(), "drop".into()],
1453 Yield { drop: None, .. }
=> vec
!["resume".into()],
1454 DropAndReplace { unwind: None, .. }
| Drop { unwind: None, .. }
=> {
1455 vec
!["return".into()]
1457 DropAndReplace { unwind: Some(_), .. }
| Drop { unwind: Some(_), .. }
=> {
1458 vec
!["return".into(), "unwind".into()]
1460 Assert { cleanup: None, .. }
=> vec
!["".into()],
1461 Assert { .. }
=> vec
!["success".into(), "unwind".into()],
1462 FalseEdges { .. }
=> vec
!["real".into(), "imaginary".into()],
1463 FalseUnwind { unwind: Some(_), .. }
=> vec
!["real".into(), "cleanup".into()],
1464 FalseUnwind { unwind: None, .. }
=> vec
!["real".into()],
1469 ///////////////////////////////////////////////////////////////////////////
1472 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
1473 pub struct Statement
<'tcx
> {
1474 pub source_info
: SourceInfo
,
1475 pub kind
: StatementKind
<'tcx
>,
1478 // `Statement` is used a lot. Make sure it doesn't unintentionally get bigger.
1479 #[cfg(target_arch = "x86_64")]
1480 static_assert_size
!(Statement
<'_
>, 32);
1482 impl Statement
<'_
> {
1483 /// Changes a statement to a nop. This is both faster than deleting instructions and avoids
1484 /// invalidating statement indices in `Location`s.
1485 pub fn make_nop(&mut self) {
1486 self.kind
= StatementKind
::Nop
1489 /// Changes a statement to a nop and returns the original statement.
1490 pub fn replace_nop(&mut self) -> Self {
1492 source_info
: self.source_info
,
1493 kind
: mem
::replace(&mut self.kind
, StatementKind
::Nop
),
1498 #[derive(Clone, Debug, PartialEq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
1499 pub enum StatementKind
<'tcx
> {
1500 /// Write the RHS Rvalue to the LHS Place.
1501 Assign(Box
<(Place
<'tcx
>, Rvalue
<'tcx
>)>),
1503 /// This represents all the reading that a pattern match may do
1504 /// (e.g., inspecting constants and discriminant values), and the
1505 /// kind of pattern it comes from. This is in order to adapt potential
1506 /// error messages to these specific patterns.
1508 /// Note that this also is emitted for regular `let` bindings to ensure that locals that are
1509 /// never accessed still get some sanity checks for, e.g., `let x: ! = ..;`
1510 FakeRead(FakeReadCause
, Box
<Place
<'tcx
>>),
1512 /// Write the discriminant for a variant to the enum Place.
1513 SetDiscriminant { place: Box<Place<'tcx>>, variant_index: VariantIdx }
,
1515 /// Start a live range for the storage of the local.
1518 /// End the current live range for the storage of the local.
1521 /// Executes a piece of inline Assembly. Stored in a Box to keep the size
1522 /// of `StatementKind` low.
1523 InlineAsm(Box
<InlineAsm
<'tcx
>>),
1525 /// Retag references in the given place, ensuring they got fresh tags. This is
1526 /// part of the Stacked Borrows model. These statements are currently only interpreted
1527 /// by miri and only generated when "-Z mir-emit-retag" is passed.
1528 /// See <https://internals.rust-lang.org/t/stacked-borrows-an-aliasing-model-for-rust/8153/>
1529 /// for more details.
1530 Retag(RetagKind
, Box
<Place
<'tcx
>>),
1532 /// Encodes a user's type ascription. These need to be preserved
1533 /// intact so that NLL can respect them. For example:
1537 /// The effect of this annotation is to relate the type `T_y` of the place `y`
1538 /// to the user-given type `T`. The effect depends on the specified variance:
1540 /// - `Covariant` -- requires that `T_y <: T`
1541 /// - `Contravariant` -- requires that `T_y :> T`
1542 /// - `Invariant` -- requires that `T_y == T`
1543 /// - `Bivariant` -- no effect
1544 AscribeUserType(Box
<(Place
<'tcx
>, UserTypeProjection
)>, ty
::Variance
),
1546 /// No-op. Useful for deleting instructions without affecting statement indices.
1550 /// Describes what kind of retag is to be performed.
1551 #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, PartialEq, Eq, HashStable)]
1552 pub enum RetagKind
{
1553 /// The initial retag when entering a function.
1555 /// Retag preparing for a two-phase borrow.
1557 /// Retagging raw pointers.
1559 /// A "normal" retag.
1563 /// The `FakeReadCause` describes the type of pattern why a FakeRead statement exists.
1564 #[derive(Copy, Clone, RustcEncodable, RustcDecodable, Debug, HashStable, PartialEq)]
1565 pub enum FakeReadCause
{
1566 /// Inject a fake read of the borrowed input at the end of each guards
1569 /// This should ensure that you cannot change the variant for an enum while
1570 /// you are in the midst of matching on it.
1573 /// `let x: !; match x {}` doesn't generate any read of x so we need to
1574 /// generate a read of x to check that it is initialized and safe.
1577 /// A fake read of the RefWithinGuard version of a bind-by-value variable
1578 /// in a match guard to ensure that it's value hasn't change by the time
1579 /// we create the OutsideGuard version.
1582 /// Officially, the semantics of
1584 /// `let pattern = <expr>;`
1586 /// is that `<expr>` is evaluated into a temporary and then this temporary is
1587 /// into the pattern.
1589 /// However, if we see the simple pattern `let var = <expr>`, we optimize this to
1590 /// evaluate `<expr>` directly into the variable `var`. This is mostly unobservable,
1591 /// but in some cases it can affect the borrow checker, as in #53695.
1592 /// Therefore, we insert a "fake read" here to ensure that we get
1593 /// appropriate errors.
1596 /// If we have an index expression like
1598 /// (*x)[1][{ x = y; 4}]
1600 /// then the first bounds check is invalidated when we evaluate the second
1601 /// index expression. Thus we create a fake borrow of `x` across the second
1602 /// indexer, which will cause a borrow check error.
1606 #[derive(Clone, Debug, PartialEq, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
1607 pub struct InlineAsm
<'tcx
> {
1608 pub asm
: hir
::InlineAsmInner
,
1609 pub outputs
: Box
<[Place
<'tcx
>]>,
1610 pub inputs
: Box
<[(Span
, Operand
<'tcx
>)]>,
1613 impl Debug
for Statement
<'_
> {
1614 fn fmt(&self, fmt
: &mut Formatter
<'_
>) -> fmt
::Result
{
1615 use self::StatementKind
::*;
1617 Assign(box(ref place
, ref rv
)) => write
!(fmt
, "{:?} = {:?}", place
, rv
),
1618 FakeRead(ref cause
, ref place
) => write
!(fmt
, "FakeRead({:?}, {:?})", cause
, place
),
1619 Retag(ref kind
, ref place
) => write
!(
1623 RetagKind
::FnEntry
=> "[fn entry] ",
1624 RetagKind
::TwoPhase
=> "[2phase] ",
1625 RetagKind
::Raw
=> "[raw] ",
1626 RetagKind
::Default
=> "",
1630 StorageLive(ref place
) => write
!(fmt
, "StorageLive({:?})", place
),
1631 StorageDead(ref place
) => write
!(fmt
, "StorageDead({:?})", place
),
1632 SetDiscriminant { ref place, variant_index }
=> {
1633 write
!(fmt
, "discriminant({:?}) = {:?}", place
, variant_index
)
1635 InlineAsm(ref asm
) => {
1636 write
!(fmt
, "asm!({:?} : {:?} : {:?})", asm
.asm
, asm
.outputs
, asm
.inputs
)
1638 AscribeUserType(box(ref place
, ref c_ty
), ref variance
) => {
1639 write
!(fmt
, "AscribeUserType({:?}, {:?}, {:?})", place
, variance
, c_ty
)
1641 Nop
=> write
!(fmt
, "nop"),
1646 ///////////////////////////////////////////////////////////////////////////
1649 /// A path to a value; something that can be evaluated without
1650 /// changing or disturbing program state.
1652 Clone
, PartialEq
, Eq
, PartialOrd
, Ord
, Hash
, RustcEncodable
, HashStable
,
1654 pub struct Place
<'tcx
> {
1655 pub base
: PlaceBase
<'tcx
>,
1657 /// projection out of a place (access a field, deref a pointer, etc)
1658 pub projection
: &'tcx List
<PlaceElem
<'tcx
>>,
1661 impl<'tcx
> rustc_serialize
::UseSpecializedDecodable
for Place
<'tcx
> {}
1664 Clone
, PartialEq
, Eq
, PartialOrd
, Ord
, Hash
, RustcEncodable
, RustcDecodable
, HashStable
,
1666 pub enum PlaceBase
<'tcx
> {
1670 /// static or static mut variable
1671 Static(Box
<Static
<'tcx
>>),
1674 /// We store the normalized type to avoid requiring normalization when reading MIR
1675 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash,
1676 RustcEncodable
, RustcDecodable
, HashStable
)]
1677 pub struct Static
<'tcx
> {
1679 pub kind
: StaticKind
<'tcx
>,
1680 /// The `DefId` of the item this static was declared in. For promoted values, usually, this is
1681 /// the same as the `DefId` of the `mir::Body` containing the `Place` this promoted appears in.
1682 /// However, after inlining, that might no longer be the case as inlined `Place`s are copied
1683 /// into the calling frame.
1688 Clone
, Debug
, PartialEq
, Eq
, PartialOrd
, Ord
, Hash
, HashStable
, RustcEncodable
, RustcDecodable
,
1690 pub enum StaticKind
<'tcx
> {
1691 /// Promoted references consist of an id (`Promoted`) and the substs necessary to monomorphize
1692 /// it. Usually, these substs are just the identity substs for the item. However, the inliner
1693 /// will adjust these substs when it inlines a function based on the substs at the callsite.
1694 Promoted(Promoted
, SubstsRef
<'tcx
>),
1698 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1699 #[derive(RustcEncodable, RustcDecodable, HashStable)]
1700 pub enum ProjectionElem
<V
, T
> {
1705 /// These indices are generated by slice patterns. Easiest to explain
1709 /// [X, _, .._, _, _] => { offset: 0, min_length: 4, from_end: false },
1710 /// [_, X, .._, _, _] => { offset: 1, min_length: 4, from_end: false },
1711 /// [_, _, .._, X, _] => { offset: 2, min_length: 4, from_end: true },
1712 /// [_, _, .._, _, X] => { offset: 1, min_length: 4, from_end: true },
1715 /// index or -index (in Python terms), depending on from_end
1717 /// The thing being indexed must be at least this long. For arrays this
1718 /// is always the exact length.
1720 /// Counting backwards from end? This is always false when indexing an
1725 /// These indices are generated by slice patterns.
1727 /// If `from_end` is true `slice[from..slice.len() - to]`.
1728 /// Otherwise `array[from..to]`.
1732 /// Whether `to` counts from the start or end of the array/slice.
1733 /// For `PlaceElem`s this is `true` if and only if the base is a slice.
1734 /// For `ProjectionKind`, this can also be `true` for arrays.
1738 /// "Downcast" to a variant of an ADT. Currently, we only introduce
1739 /// this for ADTs with more than one variant. It may be better to
1740 /// just introduce it always, or always for enums.
1742 /// The included Symbol is the name of the variant, used for printing MIR.
1743 Downcast(Option
<Symbol
>, VariantIdx
),
1746 impl<V
, T
> ProjectionElem
<V
, T
> {
1747 /// Returns `true` if the target of this projection may refer to a different region of memory
1749 fn is_indirect(&self) -> bool
{
1751 Self::Deref
=> true,
1755 | Self::ConstantIndex { .. }
1756 | Self::Subslice { .. }
1757 | Self::Downcast(_
, _
)
1763 /// Alias for projections as they appear in places, where the base is a place
1764 /// and the index is a local.
1765 pub type PlaceElem
<'tcx
> = ProjectionElem
<Local
, Ty
<'tcx
>>;
1767 impl<'tcx
> Copy
for PlaceElem
<'tcx
> { }
1769 // At least on 64 bit systems, `PlaceElem` should not be larger than two pointers.
1770 #[cfg(target_arch = "x86_64")]
1771 static_assert_size
!(PlaceElem
<'_
>, 16);
1773 /// Alias for projections as they appear in `UserTypeProjection`, where we
1774 /// need neither the `V` parameter for `Index` nor the `T` for `Field`.
1775 pub type ProjectionKind
= ProjectionElem
<(), ()>;
1777 rustc_index
::newtype_index
! {
1780 DEBUG_FORMAT
= "field[{}]"
1784 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1785 pub struct PlaceRef
<'a
, 'tcx
> {
1786 pub base
: &'a PlaceBase
<'tcx
>,
1787 pub projection
: &'a
[PlaceElem
<'tcx
>],
1790 impl<'tcx
> Place
<'tcx
> {
1791 // FIXME change this to a const fn by also making List::empty a const fn.
1792 pub fn return_place() -> Place
<'tcx
> {
1794 base
: PlaceBase
::Local(RETURN_PLACE
),
1795 projection
: List
::empty(),
1799 /// Returns `true` if this `Place` contains a `Deref` projection.
1801 /// If `Place::is_indirect` returns false, the caller knows that the `Place` refers to the
1802 /// same region of memory as its base.
1803 pub fn is_indirect(&self) -> bool
{
1804 self.projection
.iter().any(|elem
| elem
.is_indirect())
1807 /// Finds the innermost `Local` from this `Place`, *if* it is either a local itself or
1808 /// a single deref of a local.
1810 // FIXME: can we safely swap the semantics of `fn base_local` below in here instead?
1811 pub fn local_or_deref_local(&self) -> Option
<Local
> {
1812 match self.as_ref() {
1814 base
: &PlaceBase
::Local(local
),
1818 base
: &PlaceBase
::Local(local
),
1819 projection
: &[ProjectionElem
::Deref
],
1825 /// If this place represents a local variable like `_X` with no
1826 /// projections, return `Some(_X)`.
1827 pub fn as_local(&self) -> Option
<Local
> {
1828 self.as_ref().as_local()
1831 pub fn as_ref(&self) -> PlaceRef
<'_
, 'tcx
> {
1834 projection
: &self.projection
,
1839 impl From
<Local
> for Place
<'_
> {
1840 fn from(local
: Local
) -> Self {
1843 projection
: List
::empty(),
1848 impl From
<Local
> for PlaceBase
<'_
> {
1849 fn from(local
: Local
) -> Self {
1850 PlaceBase
::Local(local
)
1854 impl<'a
, 'tcx
> PlaceRef
<'a
, 'tcx
> {
1855 /// Finds the innermost `Local` from this `Place`, *if* it is either a local itself or
1856 /// a single deref of a local.
1858 // FIXME: can we safely swap the semantics of `fn base_local` below in here instead?
1859 pub fn local_or_deref_local(&self) -> Option
<Local
> {
1862 base
: PlaceBase
::Local(local
),
1866 base
: PlaceBase
::Local(local
),
1867 projection
: [ProjectionElem
::Deref
],
1873 /// If this place represents a local variable like `_X` with no
1874 /// projections, return `Some(_X)`.
1875 pub fn as_local(&self) -> Option
<Local
> {
1877 PlaceRef { base: PlaceBase::Local(l), projection: [] }
=> Some(*l
),
1883 impl Debug
for Place
<'_
> {
1884 fn fmt(&self, fmt
: &mut Formatter
<'_
>) -> fmt
::Result
{
1885 for elem
in self.projection
.iter().rev() {
1887 ProjectionElem
::Downcast(_
, _
) | ProjectionElem
::Field(_
, _
) => {
1888 write
!(fmt
, "(").unwrap();
1890 ProjectionElem
::Deref
=> {
1891 write
!(fmt
, "(*").unwrap();
1893 ProjectionElem
::Index(_
)
1894 | ProjectionElem
::ConstantIndex { .. }
1895 | ProjectionElem
::Subslice { .. }
=> {}
1899 write
!(fmt
, "{:?}", self.base
)?
;
1901 for elem
in self.projection
.iter() {
1903 ProjectionElem
::Downcast(Some(name
), _index
) => {
1904 write
!(fmt
, " as {})", name
)?
;
1906 ProjectionElem
::Downcast(None
, index
) => {
1907 write
!(fmt
, " as variant#{:?})", index
)?
;
1909 ProjectionElem
::Deref
=> {
1912 ProjectionElem
::Field(field
, ty
) => {
1913 write
!(fmt
, ".{:?}: {:?})", field
.index(), ty
)?
;
1915 ProjectionElem
::Index(ref index
) => {
1916 write
!(fmt
, "[{:?}]", index
)?
;
1918 ProjectionElem
::ConstantIndex { offset, min_length, from_end: false }
=> {
1919 write
!(fmt
, "[{:?} of {:?}]", offset
, min_length
)?
;
1921 ProjectionElem
::ConstantIndex { offset, min_length, from_end: true }
=> {
1922 write
!(fmt
, "[-{:?} of {:?}]", offset
, min_length
)?
;
1924 ProjectionElem
::Subslice { from, to, from_end: true }
if *to
== 0 => {
1925 write
!(fmt
, "[{:?}:]", from
)?
;
1927 ProjectionElem
::Subslice { from, to, from_end: true }
if *from
== 0 => {
1928 write
!(fmt
, "[:-{:?}]", to
)?
;
1930 ProjectionElem
::Subslice { from, to, from_end: true }
=> {
1931 write
!(fmt
, "[{:?}:-{:?}]", from
, to
)?
;
1933 ProjectionElem
::Subslice { from, to, from_end: false }
=> {
1934 write
!(fmt
, "[{:?}..{:?}]", from
, to
)?
;
1943 impl Debug
for PlaceBase
<'_
> {
1944 fn fmt(&self, fmt
: &mut Formatter
<'_
>) -> fmt
::Result
{
1946 PlaceBase
::Local(id
) => write
!(fmt
, "{:?}", id
),
1947 PlaceBase
::Static(box self::Static { ty, kind: StaticKind::Static, def_id }
) => {
1948 write
!(fmt
, "({}: {:?})", ty
::tls
::with(|tcx
| tcx
.def_path_str(def_id
)), ty
)
1950 PlaceBase
::Static(box self::Static
{
1951 ty
, kind
: StaticKind
::Promoted(promoted
, _
), def_id
: _
1953 write
!(fmt
, "({:?}: {:?})", promoted
, ty
)
1959 ///////////////////////////////////////////////////////////////////////////
1962 rustc_index
::newtype_index
! {
1963 pub struct SourceScope
{
1965 DEBUG_FORMAT
= "scope[{}]",
1966 const OUTERMOST_SOURCE_SCOPE
= 0,
1970 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
1971 pub struct SourceScopeData
{
1973 pub parent_scope
: Option
<SourceScope
>,
1975 /// Crate-local information for this source scope, that can't (and
1976 /// needn't) be tracked across crates.
1977 pub local_data
: ClearCrossCrate
<SourceScopeLocalData
>,
1980 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
1981 pub struct SourceScopeLocalData
{
1982 /// An `HirId` with lint levels equivalent to this scope's lint levels.
1983 pub lint_root
: hir
::HirId
,
1984 /// The unsafe block that contains this node.
1988 ///////////////////////////////////////////////////////////////////////////
1991 /// These are values that can appear inside an rvalue. They are intentionally
1992 /// limited to prevent rvalues from being nested in one another.
1993 #[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable)]
1994 pub enum Operand
<'tcx
> {
1995 /// Copy: The value must be available for use afterwards.
1997 /// This implies that the type of the place must be `Copy`; this is true
1998 /// by construction during build, but also checked by the MIR type checker.
2001 /// Move: The value (including old borrows of it) will not be used again.
2003 /// Safe for values of all types (modulo future developments towards `?Move`).
2004 /// Correct usage patterns are enforced by the borrow checker for safe code.
2005 /// `Copy` may be converted to `Move` to enable "last-use" optimizations.
2008 /// Synthesizes a constant value.
2009 Constant(Box
<Constant
<'tcx
>>),
2012 impl<'tcx
> Debug
for Operand
<'tcx
> {
2013 fn fmt(&self, fmt
: &mut Formatter
<'_
>) -> fmt
::Result
{
2014 use self::Operand
::*;
2016 Constant(ref a
) => write
!(fmt
, "{:?}", a
),
2017 Copy(ref place
) => write
!(fmt
, "{:?}", place
),
2018 Move(ref place
) => write
!(fmt
, "move {:?}", place
),
2023 impl<'tcx
> Operand
<'tcx
> {
2024 /// Convenience helper to make a constant that refers to the fn
2025 /// with given `DefId` and substs. Since this is used to synthesize
2026 /// MIR, assumes `user_ty` is None.
2027 pub fn function_handle(
2030 substs
: SubstsRef
<'tcx
>,
2033 let ty
= tcx
.type_of(def_id
).subst(tcx
, substs
);
2034 Operand
::Constant(box Constant
{
2037 literal
: ty
::Const
::zero_sized(tcx
, ty
),
2041 pub fn to_copy(&self) -> Self {
2043 Operand
::Copy(_
) | Operand
::Constant(_
) => self.clone(),
2044 Operand
::Move(ref place
) => Operand
::Copy(place
.clone()),
2049 ///////////////////////////////////////////////////////////////////////////
2052 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable, PartialEq)]
2053 pub enum Rvalue
<'tcx
> {
2054 /// x (either a move or copy, depending on type of x)
2058 Repeat(Operand
<'tcx
>, u64),
2061 Ref(Region
<'tcx
>, BorrowKind
, Place
<'tcx
>),
2063 /// length of a [X] or [X;n] value
2066 Cast(CastKind
, Operand
<'tcx
>, Ty
<'tcx
>),
2068 BinaryOp(BinOp
, Operand
<'tcx
>, Operand
<'tcx
>),
2069 CheckedBinaryOp(BinOp
, Operand
<'tcx
>, Operand
<'tcx
>),
2071 NullaryOp(NullOp
, Ty
<'tcx
>),
2072 UnaryOp(UnOp
, Operand
<'tcx
>),
2074 /// Read the discriminant of an ADT.
2076 /// Undefined (i.e., no effort is made to make it defined, but there’s no reason why it cannot
2077 /// be defined to return, say, a 0) if ADT is not an enum.
2078 Discriminant(Place
<'tcx
>),
2080 /// Creates an aggregate value, like a tuple or struct. This is
2081 /// only needed because we want to distinguish `dest = Foo { x:
2082 /// ..., y: ... }` from `dest.x = ...; dest.y = ...;` in the case
2083 /// that `Foo` has a destructor. These rvalues can be optimized
2084 /// away after type-checking and before lowering.
2085 Aggregate(Box
<AggregateKind
<'tcx
>>, Vec
<Operand
<'tcx
>>),
2088 #[derive(Clone, Copy, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)]
2091 Pointer(PointerCast
),
2094 #[derive(Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)]
2095 pub enum AggregateKind
<'tcx
> {
2096 /// The type is of the element
2100 /// The second field is the variant index. It's equal to 0 for struct
2101 /// and union expressions. The fourth field is
2102 /// active field number and is present only for union expressions
2103 /// -- e.g., for a union expression `SomeUnion { c: .. }`, the
2104 /// active field index would identity the field `c`
2105 Adt(&'tcx AdtDef
, VariantIdx
, SubstsRef
<'tcx
>, Option
<UserTypeAnnotationIndex
>, Option
<usize>),
2107 Closure(DefId
, SubstsRef
<'tcx
>),
2108 Generator(DefId
, SubstsRef
<'tcx
>, hir
::Movability
),
2111 #[derive(Copy, Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)]
2113 /// The `+` operator (addition)
2115 /// The `-` operator (subtraction)
2117 /// The `*` operator (multiplication)
2119 /// The `/` operator (division)
2121 /// The `%` operator (modulus)
2123 /// The `^` operator (bitwise xor)
2125 /// The `&` operator (bitwise and)
2127 /// The `|` operator (bitwise or)
2129 /// The `<<` operator (shift left)
2131 /// The `>>` operator (shift right)
2133 /// The `==` operator (equality)
2135 /// The `<` operator (less than)
2137 /// The `<=` operator (less than or equal to)
2139 /// The `!=` operator (not equal to)
2141 /// The `>=` operator (greater than or equal to)
2143 /// The `>` operator (greater than)
2145 /// The `ptr.offset` operator
2150 pub fn is_checkable(self) -> bool
{
2153 Add
| Sub
| Mul
| Shl
| Shr
=> true,
2159 #[derive(Copy, Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)]
2161 /// Returns the size of a value of that type
2163 /// Creates a new uninitialized box for a value of that type
2167 #[derive(Copy, Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable, HashStable)]
2169 /// The `!` operator for logical inversion
2171 /// The `-` operator for negation
2175 impl<'tcx
> Debug
for Rvalue
<'tcx
> {
2176 fn fmt(&self, fmt
: &mut Formatter
<'_
>) -> fmt
::Result
{
2177 use self::Rvalue
::*;
2180 Use(ref place
) => write
!(fmt
, "{:?}", place
),
2181 Repeat(ref a
, ref b
) => write
!(fmt
, "[{:?}; {:?}]", a
, b
),
2182 Len(ref a
) => write
!(fmt
, "Len({:?})", a
),
2183 Cast(ref kind
, ref place
, ref ty
) => {
2184 write
!(fmt
, "{:?} as {:?} ({:?})", place
, ty
, kind
)
2186 BinaryOp(ref op
, ref a
, ref b
) => write
!(fmt
, "{:?}({:?}, {:?})", op
, a
, b
),
2187 CheckedBinaryOp(ref op
, ref a
, ref b
) => {
2188 write
!(fmt
, "Checked{:?}({:?}, {:?})", op
, a
, b
)
2190 UnaryOp(ref op
, ref a
) => write
!(fmt
, "{:?}({:?})", op
, a
),
2191 Discriminant(ref place
) => write
!(fmt
, "discriminant({:?})", place
),
2192 NullaryOp(ref op
, ref t
) => write
!(fmt
, "{:?}({:?})", op
, t
),
2193 Ref(region
, borrow_kind
, ref place
) => {
2194 let kind_str
= match borrow_kind
{
2195 BorrowKind
::Shared
=> "",
2196 BorrowKind
::Shallow
=> "shallow ",
2197 BorrowKind
::Mut { .. }
| BorrowKind
::Unique
=> "mut ",
2200 // When printing regions, add trailing space if necessary.
2201 let print_region
= ty
::tls
::with(|tcx
| {
2202 tcx
.sess
.verbose() || tcx
.sess
.opts
.debugging_opts
.identify_regions
2204 let region
= if print_region
{
2205 let mut region
= region
.to_string();
2206 if region
.len() > 0 {
2211 // Do not even print 'static
2214 write
!(fmt
, "&{}{}{:?}", region
, kind_str
, place
)
2217 Aggregate(ref kind
, ref places
) => {
2218 fn fmt_tuple(fmt
: &mut Formatter
<'_
>, places
: &[Operand
<'_
>]) -> fmt
::Result
{
2219 let mut tuple_fmt
= fmt
.debug_tuple("");
2220 for place
in places
{
2221 tuple_fmt
.field(place
);
2227 AggregateKind
::Array(_
) => write
!(fmt
, "{:?}", places
),
2229 AggregateKind
::Tuple
=> match places
.len() {
2230 0 => write
!(fmt
, "()"),
2231 1 => write
!(fmt
, "({:?},)", places
[0]),
2232 _
=> fmt_tuple(fmt
, places
),
2235 AggregateKind
::Adt(adt_def
, variant
, substs
, _user_ty
, _
) => {
2236 let variant_def
= &adt_def
.variants
[variant
];
2239 ty
::tls
::with(|tcx
| {
2240 let substs
= tcx
.lift(&substs
).expect("could not lift for printing");
2241 FmtPrinter
::new(tcx
, f
, Namespace
::ValueNS
)
2242 .print_def_path(variant_def
.def_id
, substs
)?
;
2246 match variant_def
.ctor_kind
{
2247 CtorKind
::Const
=> Ok(()),
2248 CtorKind
::Fn
=> fmt_tuple(fmt
, places
),
2249 CtorKind
::Fictive
=> {
2250 let mut struct_fmt
= fmt
.debug_struct("");
2251 for (field
, place
) in variant_def
.fields
.iter().zip(places
) {
2252 struct_fmt
.field(&field
.ident
.as_str(), place
);
2259 AggregateKind
::Closure(def_id
, substs
) => ty
::tls
::with(|tcx
| {
2260 if let Some(hir_id
) = tcx
.hir().as_local_hir_id(def_id
) {
2261 let name
= if tcx
.sess
.opts
.debugging_opts
.span_free_formats
{
2262 let substs
= tcx
.lift(&substs
).unwrap();
2265 tcx
.def_path_str_with_substs(def_id
, substs
),
2268 format
!("[closure@{:?}]", tcx
.hir().span(hir_id
))
2270 let mut struct_fmt
= fmt
.debug_struct(&name
);
2272 if let Some(upvars
) = tcx
.upvars(def_id
) {
2273 for (&var_id
, place
) in upvars
.keys().zip(places
) {
2274 let var_name
= tcx
.hir().name(var_id
);
2275 struct_fmt
.field(&var_name
.as_str(), place
);
2281 write
!(fmt
, "[closure]")
2285 AggregateKind
::Generator(def_id
, _
, _
) => ty
::tls
::with(|tcx
| {
2286 if let Some(hir_id
) = tcx
.hir().as_local_hir_id(def_id
) {
2287 let name
= format
!("[generator@{:?}]", tcx
.hir().span(hir_id
));
2288 let mut struct_fmt
= fmt
.debug_struct(&name
);
2290 if let Some(upvars
) = tcx
.upvars(def_id
) {
2291 for (&var_id
, place
) in upvars
.keys().zip(places
) {
2292 let var_name
= tcx
.hir().name(var_id
);
2293 struct_fmt
.field(&var_name
.as_str(), place
);
2299 write
!(fmt
, "[generator]")
2308 ///////////////////////////////////////////////////////////////////////////
2311 /// Two constants are equal if they are the same constant. Note that
2312 /// this does not necessarily mean that they are "==" in Rust -- in
2313 /// particular one must be wary of `NaN`!
2315 #[derive(Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable)]
2316 pub struct Constant
<'tcx
> {
2319 /// Optional user-given type: for something like
2320 /// `collect::<Vec<_>>`, this would be present and would
2321 /// indicate that `Vec<_>` was explicitly specified.
2323 /// Needed for NLL to impose user-given type constraints.
2324 pub user_ty
: Option
<UserTypeAnnotationIndex
>,
2326 pub literal
: &'tcx ty
::Const
<'tcx
>,
2329 impl Constant
<'tcx
> {
2330 pub fn check_static_ptr(&self, tcx
: TyCtxt
<'_
>) -> Option
<DefId
> {
2331 match self.literal
.val
.try_to_scalar() {
2332 Some(Scalar
::Ptr(ptr
)) => match tcx
.alloc_map
.lock().get(ptr
.alloc_id
) {
2333 Some(GlobalAlloc
::Static(def_id
)) => Some(def_id
),
2336 tcx
.sess
.delay_span_bug(
2337 DUMMY_SP
, "MIR cannot contain dangling const pointers",
2347 /// A collection of projections into user types.
2349 /// They are projections because a binding can occur a part of a
2350 /// parent pattern that has been ascribed a type.
2352 /// Its a collection because there can be multiple type ascriptions on
2353 /// the path from the root of the pattern down to the binding itself.
2358 /// struct S<'a>((i32, &'a str), String);
2359 /// let S((_, w): (i32, &'static str), _): S = ...;
2360 /// // ------ ^^^^^^^^^^^^^^^^^^^ (1)
2361 /// // --------------------------------- ^ (2)
2364 /// The highlights labelled `(1)` show the subpattern `(_, w)` being
2365 /// ascribed the type `(i32, &'static str)`.
2367 /// The highlights labelled `(2)` show the whole pattern being
2368 /// ascribed the type `S`.
2370 /// In this example, when we descend to `w`, we will have built up the
2371 /// following two projected types:
2373 /// * base: `S`, projection: `(base.0).1`
2374 /// * base: `(i32, &'static str)`, projection: `base.1`
2376 /// The first will lead to the constraint `w: &'1 str` (for some
2377 /// inferred region `'1`). The second will lead to the constraint `w:
2379 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
2380 pub struct UserTypeProjections
{
2381 pub(crate) contents
: Vec
<(UserTypeProjection
, Span
)>,
2384 impl<'tcx
> UserTypeProjections
{
2385 pub fn none() -> Self {
2386 UserTypeProjections { contents: vec![] }
2389 pub fn from_projections(projs
: impl Iterator
<Item
= (UserTypeProjection
, Span
)>) -> Self {
2390 UserTypeProjections { contents: projs.collect() }
2393 pub fn projections_and_spans(&self)
2394 -> impl Iterator
<Item
= &(UserTypeProjection
, Span
)> + ExactSizeIterator
2396 self.contents
.iter()
2399 pub fn projections(&self)
2400 -> impl Iterator
<Item
= &UserTypeProjection
> + ExactSizeIterator
2402 self.contents
.iter().map(|&(ref user_type
, _span
)| user_type
)
2405 pub fn push_projection(mut self, user_ty
: &UserTypeProjection
, span
: Span
) -> Self {
2406 self.contents
.push((user_ty
.clone(), span
));
2412 mut f
: impl FnMut(UserTypeProjection
) -> UserTypeProjection
,
2414 self.contents
= self.contents
.drain(..).map(|(proj
, span
)| (f(proj
), span
)).collect();
2418 pub fn index(self) -> Self {
2419 self.map_projections(|pat_ty_proj
| pat_ty_proj
.index())
2422 pub fn subslice(self, from
: u32, to
: u32) -> Self {
2423 self.map_projections(|pat_ty_proj
| pat_ty_proj
.subslice(from
, to
))
2426 pub fn deref(self) -> Self {
2427 self.map_projections(|pat_ty_proj
| pat_ty_proj
.deref())
2430 pub fn leaf(self, field
: Field
) -> Self {
2431 self.map_projections(|pat_ty_proj
| pat_ty_proj
.leaf(field
))
2434 pub fn variant(self, adt_def
: &'tcx AdtDef
, variant_index
: VariantIdx
, field
: Field
) -> Self {
2435 self.map_projections(|pat_ty_proj
| pat_ty_proj
.variant(adt_def
, variant_index
, field
))
2439 /// Encodes the effect of a user-supplied type annotation on the
2440 /// subcomponents of a pattern. The effect is determined by applying the
2441 /// given list of proejctions to some underlying base type. Often,
2442 /// the projection element list `projs` is empty, in which case this
2443 /// directly encodes a type in `base`. But in the case of complex patterns with
2444 /// subpatterns and bindings, we want to apply only a *part* of the type to a variable,
2445 /// in which case the `projs` vector is used.
2449 /// * `let x: T = ...` -- here, the `projs` vector is empty.
2451 /// * `let (x, _): T = ...` -- here, the `projs` vector would contain
2452 /// `field[0]` (aka `.0`), indicating that the type of `s` is
2453 /// determined by finding the type of the `.0` field from `T`.
2454 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, PartialEq)]
2455 pub struct UserTypeProjection
{
2456 pub base
: UserTypeAnnotationIndex
,
2457 pub projs
: Vec
<ProjectionKind
>,
2460 impl Copy
for ProjectionKind {}
2462 impl UserTypeProjection
{
2463 pub(crate) fn index(mut self) -> Self {
2464 self.projs
.push(ProjectionElem
::Index(()));
2468 pub(crate) fn subslice(mut self, from
: u32, to
: u32) -> Self {
2469 self.projs
.push(ProjectionElem
::Subslice { from, to, from_end: true }
);
2473 pub(crate) fn deref(mut self) -> Self {
2474 self.projs
.push(ProjectionElem
::Deref
);
2478 pub(crate) fn leaf(mut self, field
: Field
) -> Self {
2479 self.projs
.push(ProjectionElem
::Field(field
, ()));
2483 pub(crate) fn variant(
2485 adt_def
: &'tcx AdtDef
,
2486 variant_index
: VariantIdx
,
2489 self.projs
.push(ProjectionElem
::Downcast(
2490 Some(adt_def
.variants
[variant_index
].ident
.name
),
2493 self.projs
.push(ProjectionElem
::Field(field
, ()));
2498 CloneTypeFoldableAndLiftImpls
! { ProjectionKind, }
2500 impl<'tcx
> TypeFoldable
<'tcx
> for UserTypeProjection
{
2501 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
2502 use crate::mir
::ProjectionElem
::*;
2504 let base
= self.base
.fold_with(folder
);
2505 let projs
: Vec
<_
> = self
2508 .map(|elem
| match elem
{
2510 Field(f
, ()) => Field(f
.clone(), ()),
2511 Index(()) => Index(()),
2512 elem
=> elem
.clone(),
2516 UserTypeProjection { base, projs }
2519 fn super_visit_with
<Vs
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut Vs
) -> bool
{
2520 self.base
.visit_with(visitor
)
2521 // Note: there's nothing in `self.proj` to visit.
2525 rustc_index
::newtype_index
! {
2526 pub struct Promoted
{
2528 DEBUG_FORMAT
= "promoted[{}]"
2532 impl<'tcx
> Debug
for Constant
<'tcx
> {
2533 fn fmt(&self, fmt
: &mut Formatter
<'_
>) -> fmt
::Result
{
2534 write
!(fmt
, "{}", self)
2538 impl<'tcx
> Display
for Constant
<'tcx
> {
2539 fn fmt(&self, fmt
: &mut Formatter
<'_
>) -> fmt
::Result
{
2540 write
!(fmt
, "const ")?
;
2541 // FIXME make the default pretty printing of raw pointers more detailed. Here we output the
2542 // debug representation of raw pointers, so that the raw pointers in the mir dump output are
2543 // detailed and just not '{pointer}'.
2544 if let ty
::RawPtr(_
) = self.literal
.ty
.kind
{
2545 write
!(fmt
, "{:?} : {}", self.literal
.val
, self.literal
.ty
)
2547 write
!(fmt
, "{}", self.literal
)
2552 impl<'tcx
> graph
::DirectedGraph
for Body
<'tcx
> {
2553 type Node
= BasicBlock
;
2556 impl<'tcx
> graph
::WithNumNodes
for Body
<'tcx
> {
2557 fn num_nodes(&self) -> usize {
2558 self.basic_blocks
.len()
2562 impl<'tcx
> graph
::WithStartNode
for Body
<'tcx
> {
2563 fn start_node(&self) -> Self::Node
{
2568 impl<'tcx
> graph
::WithSuccessors
for Body
<'tcx
> {
2572 ) -> <Self as GraphSuccessors
<'_
>>::Iter
{
2573 self.basic_blocks
[node
].terminator().successors().cloned()
2577 impl<'a
, 'b
> graph
::GraphSuccessors
<'b
> for Body
<'a
> {
2578 type Item
= BasicBlock
;
2579 type Iter
= iter
::Cloned
<Successors
<'b
>>;
2582 #[derive(Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd, HashStable)]
2583 pub struct Location
{
2584 /// The block that the location is within.
2585 pub block
: BasicBlock
,
2587 /// The location is the position of the start of the statement; or, if
2588 /// `statement_index` equals the number of statements, then the start of the
2590 pub statement_index
: usize,
2593 impl fmt
::Debug
for Location
{
2594 fn fmt(&self, fmt
: &mut fmt
::Formatter
<'_
>) -> fmt
::Result
{
2595 write
!(fmt
, "{:?}[{}]", self.block
, self.statement_index
)
2600 pub const START
: Location
= Location { block: START_BLOCK, statement_index: 0 }
;
2602 /// Returns the location immediately after this one within the enclosing block.
2604 /// Note that if this location represents a terminator, then the
2605 /// resulting location would be out of bounds and invalid.
2606 pub fn successor_within_block(&self) -> Location
{
2607 Location { block: self.block, statement_index: self.statement_index + 1 }
2610 /// Returns `true` if `other` is earlier in the control flow graph than `self`.
2611 pub fn is_predecessor_of
<'tcx
>(
2614 body
: ReadOnlyBodyAndCache
<'_
, 'tcx
>
2616 // If we are in the same block as the other location and are an earlier statement
2617 // then we are a predecessor of `other`.
2618 if self.block
== other
.block
&& self.statement_index
< other
.statement_index
{
2622 // If we're in another block, then we want to check that block is a predecessor of `other`.
2623 let mut queue
: Vec
<BasicBlock
> = body
.predecessors_for(other
.block
).to_vec();
2624 let mut visited
= FxHashSet
::default();
2626 while let Some(block
) = queue
.pop() {
2627 // If we haven't visited this block before, then make sure we visit it's predecessors.
2628 if visited
.insert(block
) {
2629 queue
.extend(body
.predecessors_for(block
).iter().cloned());
2634 // If we found the block that `self` is in, then we are a predecessor of `other` (since
2635 // we found that block by looking at the predecessors of `other`).
2636 if self.block
== block
{
2644 pub fn dominates(&self, other
: Location
, dominators
: &Dominators
<BasicBlock
>) -> bool
{
2645 if self.block
== other
.block
{
2646 self.statement_index
<= other
.statement_index
2648 dominators
.is_dominated_by(other
.block
, self.block
)
2653 #[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable)]
2654 pub enum UnsafetyViolationKind
{
2656 /// Permitted both in `const fn`s and regular `fn`s.
2658 BorrowPacked(hir
::HirId
),
2661 #[derive(Copy, Clone, PartialEq, RustcEncodable, RustcDecodable, HashStable)]
2662 pub struct UnsafetyViolation
{
2663 pub source_info
: SourceInfo
,
2664 pub description
: Symbol
,
2665 pub details
: Symbol
,
2666 pub kind
: UnsafetyViolationKind
,
2669 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
2670 pub struct UnsafetyCheckResult
{
2671 /// Violations that are propagated *upwards* from this function.
2672 pub violations
: Lrc
<[UnsafetyViolation
]>,
2673 /// `unsafe` blocks in this function, along with whether they are used. This is
2674 /// used for the "unused_unsafe" lint.
2675 pub unsafe_blocks
: Lrc
<[(hir
::HirId
, bool
)]>,
2678 rustc_index
::newtype_index
! {
2679 pub struct GeneratorSavedLocal
{
2681 DEBUG_FORMAT
= "_{}",
2685 /// The layout of generator state.
2686 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable, TypeFoldable)]
2687 pub struct GeneratorLayout
<'tcx
> {
2688 /// The type of every local stored inside the generator.
2689 pub field_tys
: IndexVec
<GeneratorSavedLocal
, Ty
<'tcx
>>,
2691 /// Which of the above fields are in each variant. Note that one field may
2692 /// be stored in multiple variants.
2693 pub variant_fields
: IndexVec
<VariantIdx
, IndexVec
<Field
, GeneratorSavedLocal
>>,
2695 /// Which saved locals are storage-live at the same time. Locals that do not
2696 /// have conflicts with each other are allowed to overlap in the computed
2698 pub storage_conflicts
: BitMatrix
<GeneratorSavedLocal
, GeneratorSavedLocal
>,
2701 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
2702 pub struct BorrowCheckResult
<'tcx
> {
2703 pub closure_requirements
: Option
<ClosureRegionRequirements
<'tcx
>>,
2704 pub used_mut_upvars
: SmallVec
<[Field
; 8]>,
2707 /// The result of the `mir_const_qualif` query.
2709 /// Each field corresponds to an implementer of the `Qualif` trait in
2710 /// `librustc_mir/transform/check_consts/qualifs.rs`. See that file for more information on each
2712 #[derive(Clone, Copy, Debug, Default, RustcEncodable, RustcDecodable, HashStable)]
2713 pub struct ConstQualifs
{
2714 pub has_mut_interior
: bool
,
2715 pub needs_drop
: bool
,
2718 /// After we borrow check a closure, we are left with various
2719 /// requirements that we have inferred between the free regions that
2720 /// appear in the closure's signature or on its field types. These
2721 /// requirements are then verified and proved by the closure's
2722 /// creating function. This struct encodes those requirements.
2724 /// The requirements are listed as being between various
2725 /// `RegionVid`. The 0th region refers to `'static`; subsequent region
2726 /// vids refer to the free regions that appear in the closure (or
2727 /// generator's) type, in order of appearance. (This numbering is
2728 /// actually defined by the `UniversalRegions` struct in the NLL
2729 /// region checker. See for example
2730 /// `UniversalRegions::closure_mapping`.) Note that we treat the free
2731 /// regions in the closure's type "as if" they were erased, so their
2732 /// precise identity is not important, only their position.
2734 /// Example: If type check produces a closure with the closure substs:
2737 /// ClosureSubsts = [
2738 /// i8, // the "closure kind"
2739 /// for<'x> fn(&'a &'x u32) -> &'x u32, // the "closure signature"
2740 /// &'a String, // some upvar
2744 /// here, there is one unique free region (`'a`) but it appears
2745 /// twice. We would "renumber" each occurrence to a unique vid, as follows:
2748 /// ClosureSubsts = [
2749 /// i8, // the "closure kind"
2750 /// for<'x> fn(&'1 &'x u32) -> &'x u32, // the "closure signature"
2751 /// &'2 String, // some upvar
2755 /// Now the code might impose a requirement like `'1: '2`. When an
2756 /// instance of the closure is created, the corresponding free regions
2757 /// can be extracted from its type and constrained to have the given
2758 /// outlives relationship.
2760 /// In some cases, we have to record outlives requirements between
2761 /// types and regions as well. In that case, if those types include
2762 /// any regions, those regions are recorded as `ReClosureBound`
2763 /// instances assigned one of these same indices. Those regions will
2764 /// be substituted away by the creator. We use `ReClosureBound` in
2765 /// that case because the regions must be allocated in the global
2766 /// `TyCtxt`, and hence we cannot use `ReVar` (which is what we use
2767 /// internally within the rest of the NLL code).
2768 #[derive(Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
2769 pub struct ClosureRegionRequirements
<'tcx
> {
2770 /// The number of external regions defined on the closure. In our
2771 /// example above, it would be 3 -- one for `'static`, then `'1`
2772 /// and `'2`. This is just used for a sanity check later on, to
2773 /// make sure that the number of regions we see at the callsite
2775 pub num_external_vids
: usize,
2777 /// Requirements between the various free regions defined in
2779 pub outlives_requirements
: Vec
<ClosureOutlivesRequirement
<'tcx
>>,
2782 /// Indicates an outlives-constraint between a type or between two
2783 /// free regions declared on the closure.
2784 #[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
2785 pub struct ClosureOutlivesRequirement
<'tcx
> {
2786 // This region or type ...
2787 pub subject
: ClosureOutlivesSubject
<'tcx
>,
2789 // ... must outlive this one.
2790 pub outlived_free_region
: ty
::RegionVid
,
2792 // If not, report an error here ...
2793 pub blame_span
: Span
,
2795 // ... due to this reason.
2796 pub category
: ConstraintCategory
,
2799 /// Outlives-constraints can be categorized to determine whether and why they
2800 /// are interesting (for error reporting). Order of variants indicates sort
2801 /// order of the category, thereby influencing diagnostic output.
2803 /// See also [rustc_mir::borrow_check::nll::constraints].
2817 pub enum ConstraintCategory
{
2825 /// A constraint that came from checking the body of a closure.
2827 /// We try to get the category that the closure used when reporting this.
2835 /// A "boring" constraint (caused by the given location) is one that
2836 /// the user probably doesn't want to see described in diagnostics,
2837 /// because it is kind of an artifact of the type system setup.
2838 /// Example: `x = Foo { field: y }` technically creates
2839 /// intermediate regions representing the "type of `Foo { field: y
2840 /// }`", and data flows from `y` into those variables, but they
2841 /// are not very interesting. The assignment into `x` on the other
2844 // Boring and applicable everywhere.
2847 /// A constraint that doesn't correspond to anything the user sees.
2851 /// The subject of a `ClosureOutlivesRequirement` -- that is, the thing
2852 /// that must outlive some region.
2853 #[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable, HashStable)]
2854 pub enum ClosureOutlivesSubject
<'tcx
> {
2855 /// Subject is a type, typically a type parameter, but could also
2856 /// be a projection. Indicates a requirement like `T: 'a` being
2857 /// passed to the caller, where the type here is `T`.
2859 /// The type here is guaranteed not to contain any free regions at
2863 /// Subject is a free region from the closure. Indicates a requirement
2864 /// like `'a: 'b` being passed to the caller; the region here is `'a`.
2865 Region(ty
::RegionVid
),
2869 * `TypeFoldable` implementations for MIR types
2872 CloneTypeFoldableAndLiftImpls
! {
2881 SourceScopeLocalData
,
2882 UserTypeAnnotationIndex
,
2885 impl<'tcx
> TypeFoldable
<'tcx
> for Terminator
<'tcx
> {
2886 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
2887 use crate::mir
::TerminatorKind
::*;
2889 let kind
= match self.kind
{
2890 Goto { target }
=> Goto { target }
,
2891 SwitchInt { ref discr, switch_ty, ref values, ref targets }
=> SwitchInt
{
2892 discr
: discr
.fold_with(folder
),
2893 switch_ty
: switch_ty
.fold_with(folder
),
2894 values
: values
.clone(),
2895 targets
: targets
.clone(),
2897 Drop { ref location, target, unwind }
=> {
2898 Drop { location: location.fold_with(folder), target, unwind }
2900 DropAndReplace { ref location, ref value, target, unwind }
=> DropAndReplace
{
2901 location
: location
.fold_with(folder
),
2902 value
: value
.fold_with(folder
),
2906 Yield { ref value, resume, drop }
=> {
2907 Yield { value: value.fold_with(folder), resume: resume, drop: drop }
2909 Call { ref func, ref args, ref destination, cleanup, from_hir_call }
=> {
2911 destination
.as_ref().map(|&(ref loc
, dest
)| (loc
.fold_with(folder
), dest
));
2914 func
: func
.fold_with(folder
),
2915 args
: args
.fold_with(folder
),
2921 Assert { ref cond, expected, ref msg, target, cleanup }
=> {
2923 let msg
= match msg
{
2924 BoundsCheck { ref len, ref index }
=>
2926 len
: len
.fold_with(folder
),
2927 index
: index
.fold_with(folder
),
2929 Panic { .. }
| Overflow(_
) | OverflowNeg
| DivisionByZero
| RemainderByZero
|
2930 ResumedAfterReturn(_
) | ResumedAfterPanic(_
) =>
2933 Assert { cond: cond.fold_with(folder), expected, msg, target, cleanup }
2935 GeneratorDrop
=> GeneratorDrop
,
2939 Unreachable
=> Unreachable
,
2940 FalseEdges { real_target, imaginary_target }
=> {
2941 FalseEdges { real_target, imaginary_target }
2943 FalseUnwind { real_target, unwind }
=> FalseUnwind { real_target, unwind }
,
2945 Terminator { source_info: self.source_info, kind }
2948 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
2949 use crate::mir
::TerminatorKind
::*;
2952 SwitchInt { ref discr, switch_ty, .. }
=> {
2953 discr
.visit_with(visitor
) || switch_ty
.visit_with(visitor
)
2955 Drop { ref location, .. }
=> location
.visit_with(visitor
),
2956 DropAndReplace { ref location, ref value, .. }
=> {
2957 location
.visit_with(visitor
) || value
.visit_with(visitor
)
2959 Yield { ref value, .. }
=> value
.visit_with(visitor
),
2960 Call { ref func, ref args, ref destination, .. }
=> {
2961 let dest
= if let Some((ref loc
, _
)) = *destination
{
2962 loc
.visit_with(visitor
)
2966 dest
|| func
.visit_with(visitor
) || args
.visit_with(visitor
)
2968 Assert { ref cond, ref msg, .. }
=> {
2969 if cond
.visit_with(visitor
) {
2972 BoundsCheck { ref len, ref index }
=>
2973 len
.visit_with(visitor
) || index
.visit_with(visitor
),
2974 Panic { .. }
| Overflow(_
) | OverflowNeg
|
2975 DivisionByZero
| RemainderByZero
|
2976 ResumedAfterReturn(_
) | ResumedAfterPanic(_
) =>
2990 | FalseUnwind { .. }
=> false,
2995 impl<'tcx
> TypeFoldable
<'tcx
> for GeneratorKind
{
2996 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, _
: &mut F
) -> Self {
3000 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, _
: &mut V
) -> bool
{
3005 impl<'tcx
> TypeFoldable
<'tcx
> for Place
<'tcx
> {
3006 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
3008 base
: self.base
.fold_with(folder
),
3009 projection
: self.projection
.fold_with(folder
),
3013 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
3014 self.base
.visit_with(visitor
) || self.projection
.visit_with(visitor
)
3018 impl<'tcx
> TypeFoldable
<'tcx
> for PlaceBase
<'tcx
> {
3019 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
3021 PlaceBase
::Local(local
) => PlaceBase
::Local(local
.fold_with(folder
)),
3022 PlaceBase
::Static(static_
) => PlaceBase
::Static(static_
.fold_with(folder
)),
3026 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
3028 PlaceBase
::Local(local
) => local
.visit_with(visitor
),
3029 PlaceBase
::Static(static_
) => (**static_
).visit_with(visitor
),
3034 impl<'tcx
> TypeFoldable
<'tcx
> for &'tcx ty
::List
<PlaceElem
<'tcx
>> {
3035 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
3036 let v
= self.iter().map(|t
| t
.fold_with(folder
)).collect
::<Vec
<_
>>();
3037 folder
.tcx().intern_place_elems(&v
)
3040 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
3041 self.iter().any(|t
| t
.visit_with(visitor
))
3045 impl<'tcx
> TypeFoldable
<'tcx
> for Static
<'tcx
> {
3046 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
3048 ty
: self.ty
.fold_with(folder
),
3049 kind
: self.kind
.fold_with(folder
),
3050 def_id
: self.def_id
,
3054 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
3055 let Static { ty, kind, def_id: _ }
= self;
3057 ty
.visit_with(visitor
) || kind
.visit_with(visitor
)
3061 impl<'tcx
> TypeFoldable
<'tcx
> for StaticKind
<'tcx
> {
3062 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
3064 StaticKind
::Promoted(promoted
, substs
) =>
3065 StaticKind
::Promoted(promoted
.fold_with(folder
), substs
.fold_with(folder
)),
3066 StaticKind
::Static
=> StaticKind
::Static
3070 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
3072 StaticKind
::Promoted(promoted
, substs
) =>
3073 promoted
.visit_with(visitor
) || substs
.visit_with(visitor
),
3074 StaticKind
::Static
=> { false }
3079 impl<'tcx
> TypeFoldable
<'tcx
> for Rvalue
<'tcx
> {
3080 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
3081 use crate::mir
::Rvalue
::*;
3083 Use(ref op
) => Use(op
.fold_with(folder
)),
3084 Repeat(ref op
, len
) => Repeat(op
.fold_with(folder
), len
),
3085 Ref(region
, bk
, ref place
) => {
3086 Ref(region
.fold_with(folder
), bk
, place
.fold_with(folder
))
3088 Len(ref place
) => Len(place
.fold_with(folder
)),
3089 Cast(kind
, ref op
, ty
) => Cast(kind
, op
.fold_with(folder
), ty
.fold_with(folder
)),
3090 BinaryOp(op
, ref rhs
, ref lhs
) => {
3091 BinaryOp(op
, rhs
.fold_with(folder
), lhs
.fold_with(folder
))
3093 CheckedBinaryOp(op
, ref rhs
, ref lhs
) => {
3094 CheckedBinaryOp(op
, rhs
.fold_with(folder
), lhs
.fold_with(folder
))
3096 UnaryOp(op
, ref val
) => UnaryOp(op
, val
.fold_with(folder
)),
3097 Discriminant(ref place
) => Discriminant(place
.fold_with(folder
)),
3098 NullaryOp(op
, ty
) => NullaryOp(op
, ty
.fold_with(folder
)),
3099 Aggregate(ref kind
, ref fields
) => {
3100 let kind
= box match **kind
{
3101 AggregateKind
::Array(ty
) => AggregateKind
::Array(ty
.fold_with(folder
)),
3102 AggregateKind
::Tuple
=> AggregateKind
::Tuple
,
3103 AggregateKind
::Adt(def
, v
, substs
, user_ty
, n
) => AggregateKind
::Adt(
3106 substs
.fold_with(folder
),
3107 user_ty
.fold_with(folder
),
3110 AggregateKind
::Closure(id
, substs
) => {
3111 AggregateKind
::Closure(id
, substs
.fold_with(folder
))
3113 AggregateKind
::Generator(id
, substs
, movablity
) => {
3114 AggregateKind
::Generator(id
, substs
.fold_with(folder
), movablity
)
3117 Aggregate(kind
, fields
.fold_with(folder
))
3122 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
3123 use crate::mir
::Rvalue
::*;
3125 Use(ref op
) => op
.visit_with(visitor
),
3126 Repeat(ref op
, _
) => op
.visit_with(visitor
),
3127 Ref(region
, _
, ref place
) => region
.visit_with(visitor
) || place
.visit_with(visitor
),
3128 Len(ref place
) => place
.visit_with(visitor
),
3129 Cast(_
, ref op
, ty
) => op
.visit_with(visitor
) || ty
.visit_with(visitor
),
3130 BinaryOp(_
, ref rhs
, ref lhs
) | CheckedBinaryOp(_
, ref rhs
, ref lhs
) => {
3131 rhs
.visit_with(visitor
) || lhs
.visit_with(visitor
)
3133 UnaryOp(_
, ref val
) => val
.visit_with(visitor
),
3134 Discriminant(ref place
) => place
.visit_with(visitor
),
3135 NullaryOp(_
, ty
) => ty
.visit_with(visitor
),
3136 Aggregate(ref kind
, ref fields
) => {
3138 AggregateKind
::Array(ty
) => ty
.visit_with(visitor
),
3139 AggregateKind
::Tuple
=> false,
3140 AggregateKind
::Adt(_
, _
, substs
, user_ty
, _
) => {
3141 substs
.visit_with(visitor
) || user_ty
.visit_with(visitor
)
3143 AggregateKind
::Closure(_
, substs
) => substs
.visit_with(visitor
),
3144 AggregateKind
::Generator(_
, substs
, _
) => substs
.visit_with(visitor
),
3145 }) || fields
.visit_with(visitor
)
3151 impl<'tcx
> TypeFoldable
<'tcx
> for Operand
<'tcx
> {
3152 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
3154 Operand
::Copy(ref place
) => Operand
::Copy(place
.fold_with(folder
)),
3155 Operand
::Move(ref place
) => Operand
::Move(place
.fold_with(folder
)),
3156 Operand
::Constant(ref c
) => Operand
::Constant(c
.fold_with(folder
)),
3160 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
3162 Operand
::Copy(ref place
) | Operand
::Move(ref place
) => place
.visit_with(visitor
),
3163 Operand
::Constant(ref c
) => c
.visit_with(visitor
),
3168 impl<'tcx
> TypeFoldable
<'tcx
> for PlaceElem
<'tcx
> {
3169 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
3170 use crate::mir
::ProjectionElem
::*;
3174 Field(f
, ty
) => Field(*f
, ty
.fold_with(folder
)),
3175 Index(v
) => Index(v
.fold_with(folder
)),
3176 elem
=> elem
.clone(),
3180 fn super_visit_with
<Vs
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut Vs
) -> bool
{
3181 use crate::mir
::ProjectionElem
::*;
3184 Field(_
, ty
) => ty
.visit_with(visitor
),
3185 Index(v
) => v
.visit_with(visitor
),
3191 impl<'tcx
> TypeFoldable
<'tcx
> for Field
{
3192 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, _
: &mut F
) -> Self {
3195 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, _
: &mut V
) -> bool
{
3200 impl<'tcx
> TypeFoldable
<'tcx
> for GeneratorSavedLocal
{
3201 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, _
: &mut F
) -> Self {
3204 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, _
: &mut V
) -> bool
{
3209 impl<'tcx
, R
: Idx
, C
: Idx
> TypeFoldable
<'tcx
> for BitMatrix
<R
, C
> {
3210 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, _
: &mut F
) -> Self {
3213 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, _
: &mut V
) -> bool
{
3218 impl<'tcx
> TypeFoldable
<'tcx
> for Constant
<'tcx
> {
3219 fn super_fold_with
<F
: TypeFolder
<'tcx
>>(&self, folder
: &mut F
) -> Self {
3221 span
: self.span
.clone(),
3222 user_ty
: self.user_ty
.fold_with(folder
),
3223 literal
: self.literal
.fold_with(folder
),
3226 fn super_visit_with
<V
: TypeVisitor
<'tcx
>>(&self, visitor
: &mut V
) -> bool
{
3227 self.literal
.visit_with(visitor
)