compiler/rustc_middle/src/mir/visit.rs

   1 //! # The MIR Visitor
   2 //!
   3 //! ## Overview
   4 //!
   5 //! There are two visitors, one for immutable and one for mutable references,
   6 //! but both are generated by the following macro. The code is written according
   7 //! to the following conventions:
   8 //!
   9 //! - introduce a `visit_foo` and a `super_foo` method for every MIR type
  10 //! - `visit_foo`, by default, calls `super_foo`
  11 //! - `super_foo`, by default, destructures the `foo` and calls `visit_foo`
  12 //!
  13 //! This allows you as a user to override `visit_foo` for types are
  14 //! interested in, and invoke (within that method) call
  15 //! `self.super_foo` to get the default behavior. Just as in an OO
  16 //! language, you should never call `super` methods ordinarily except
  17 //! in that circumstance.
  18 //!
  19 //! For the most part, we do not destructure things external to the
  20 //! MIR, e.g., types, spans, etc, but simply visit them and stop. This
  21 //! avoids duplication with other visitors like `TypeFoldable`.
  22 //!
  23 //! ## Updating
  24 //!
  25 //! The code is written in a very deliberate style intended to minimize
  26 //! the chance of things being overlooked. You'll notice that we always
  27 //! use pattern matching to reference fields and we ensure that all
  28 //! matches are exhaustive.
  29 //!
  30 //! For example, the `super_basic_block_data` method begins like this:
  31 //!
  32 //! ```rust
  33 //! fn super_basic_block_data(&mut self,
  34 //!                           block: BasicBlock,
  35 //!                           data: & $($mutability)? BasicBlockData<'tcx>) {
  36 //!     let BasicBlockData {
  37 //!         statements,
  38 //!         terminator,
  39 //!         is_cleanup: _
  40 //!     } = *data;
  41 //!
  42 //!     for statement in statements {
  43 //!         self.visit_statement(block, statement);
  44 //!     }
  45 //!
  46 //!     ...
  47 //! }
  48 //! ```
  49 //!
  50 //! Here we used `let BasicBlockData { <fields> } = *data` deliberately,
  51 //! rather than writing `data.statements` in the body. This is because if one
  52 //! adds a new field to `BasicBlockData`, one will be forced to revise this code,
  53 //! and hence one will (hopefully) invoke the correct visit methods (if any).
  54 //!
  55 //! For this to work, ALL MATCHES MUST BE EXHAUSTIVE IN FIELDS AND VARIANTS.
  56 //! That means you never write `..` to skip over fields, nor do you write `_`
  57 //! to skip over variants in a `match`.
  58 //!
  59 //! The only place that `_` is acceptable is to match a field (or
  60 //! variant argument) that does not require visiting, as in
  61 //! `is_cleanup` above.
  62
  63 use crate::mir::*;
  64 use crate::ty::subst::SubstsRef;
  65 use crate::ty::{CanonicalUserTypeAnnotation, Ty};
  66 use rustc_span::Span;
  67
  68 macro_rules! make_mir_visitor {
  69     ($visitor_trait_name:ident, $($mutability:ident)?) => {
  70         pub trait $visitor_trait_name<'tcx> {
  71             // Override these, and call `self.super_xxx` to revert back to the
  72             // default behavior.
  73
  74             fn visit_body(
  75                 &mut self,
  76                 body: &$($mutability)? Body<'tcx>,
  77             ) {
  78                 self.super_body(body);
  79             }
  80
  81             fn visit_basic_block_data(&mut self,
  82                                       block: BasicBlock,
  83                                       data: & $($mutability)? BasicBlockData<'tcx>) {
  84                 self.super_basic_block_data(block, data);
  85             }
  86
  87             fn visit_source_scope_data(&mut self,
  88                                            scope_data: & $($mutability)? SourceScopeData<'tcx>) {
  89                 self.super_source_scope_data(scope_data);
  90             }
  91
  92             fn visit_statement(&mut self,
  93                                statement: & $($mutability)? Statement<'tcx>,
  94                                location: Location) {
  95                 self.super_statement(statement, location);
  96             }
  97
  98             fn visit_assign(&mut self,
  99                             place: & $($mutability)? Place<'tcx>,
 100                             rvalue: & $($mutability)? Rvalue<'tcx>,
 101                             location: Location) {
 102                 self.super_assign(place, rvalue, location);
 103             }
 104
 105             fn visit_terminator(&mut self,
 106                                 terminator: & $($mutability)? Terminator<'tcx>,
 107                                 location: Location) {
 108                 self.super_terminator(terminator, location);
 109             }
 110
 111             fn visit_assert_message(&mut self,
 112                                     msg: & $($mutability)? AssertMessage<'tcx>,
 113                                     location: Location) {
 114                 self.super_assert_message(msg, location);
 115             }
 116
 117             fn visit_rvalue(&mut self,
 118                             rvalue: & $($mutability)? Rvalue<'tcx>,
 119                             location: Location) {
 120                 self.super_rvalue(rvalue, location);
 121             }
 122
 123             fn visit_operand(&mut self,
 124                              operand: & $($mutability)? Operand<'tcx>,
 125                              location: Location) {
 126                 self.super_operand(operand, location);
 127             }
 128
 129             fn visit_ascribe_user_ty(&mut self,
 130                                      place: & $($mutability)? Place<'tcx>,
 131                                      variance: & $($mutability)? ty::Variance,
 132                                      user_ty: & $($mutability)? UserTypeProjection,
 133                                      location: Location) {
 134                 self.super_ascribe_user_ty(place, variance, user_ty, location);
 135             }
 136
 137             fn visit_coverage(&mut self,
 138                               coverage: & $($mutability)? Coverage,
 139                               location: Location) {
 140                 self.super_coverage(coverage, location);
 141             }
 142
 143             fn visit_retag(&mut self,
 144                            kind: & $($mutability)? RetagKind,
 145                            place: & $($mutability)? Place<'tcx>,
 146                            location: Location) {
 147                 self.super_retag(kind, place, location);
 148             }
 149
 150             fn visit_place(&mut self,
 151                             place: & $($mutability)? Place<'tcx>,
 152                             context: PlaceContext,
 153                             location: Location) {
 154                 self.super_place(place, context, location);
 155             }
 156
 157             visit_place_fns!($($mutability)?);
 158
 159             fn visit_constant(&mut self,
 160                               constant: & $($mutability)? Constant<'tcx>,
 161                               location: Location) {
 162                 self.super_constant(constant, location);
 163             }
 164
 165             // The macro results in a false positive of sorts, where &mut Span
 166             // is fine, but &Span is not; just allow the lint.
 167             #[allow(rustc::pass_by_value)]
 168             fn visit_span(&mut self,
 169                           span: & $($mutability)? Span) {
 170                 self.super_span(span);
 171             }
 172
 173             fn visit_source_info(&mut self,
 174                                  source_info: & $($mutability)? SourceInfo) {
 175                 self.super_source_info(source_info);
 176             }
 177
 178             fn visit_ty(&mut self,
 179                         ty: $(& $mutability)? Ty<'tcx>,
 180                         _: TyContext) {
 181                 self.super_ty(ty);
 182             }
 183
 184             fn visit_user_type_projection(
 185                 &mut self,
 186                 ty: & $($mutability)? UserTypeProjection,
 187             ) {
 188                 self.super_user_type_projection(ty);
 189             }
 190
 191             fn visit_user_type_annotation(
 192                 &mut self,
 193                 index: UserTypeAnnotationIndex,
 194                 ty: & $($mutability)? CanonicalUserTypeAnnotation<'tcx>,
 195             ) {
 196                 self.super_user_type_annotation(index, ty);
 197             }
 198
 199             fn visit_region(&mut self,
 200                             region: $(& $mutability)? ty::Region<'tcx>,
 201                             _: Location) {
 202                 self.super_region(region);
 203             }
 204
 205             fn visit_const(&mut self,
 206                            constant: $(& $mutability)? ty::Const<'tcx>,
 207                            _: Location) {
 208                 self.super_const(constant);
 209             }
 210
 211             fn visit_substs(&mut self,
 212                             substs: & $($mutability)? SubstsRef<'tcx>,
 213                             _: Location) {
 214                 self.super_substs(substs);
 215             }
 216
 217             fn visit_local_decl(&mut self,
 218                                 local: Local,
 219                                 local_decl: & $($mutability)? LocalDecl<'tcx>) {
 220                 self.super_local_decl(local, local_decl);
 221             }
 222
 223             fn visit_var_debug_info(&mut self,
 224                                     var_debug_info: & $($mutability)* VarDebugInfo<'tcx>) {
 225                 self.super_var_debug_info(var_debug_info);
 226             }
 227
 228             #[allow(rustc::pass_by_value)]
 229             fn visit_local(&mut self,
 230                             _local: & $($mutability)? Local,
 231                             _context: PlaceContext,
 232                             _location: Location) {
 233             }
 234
 235             #[allow(rustc::pass_by_value)]
 236             fn visit_source_scope(&mut self,
 237                                       scope: & $($mutability)? SourceScope) {
 238                 self.super_source_scope(scope);
 239             }
 240
 241             // The `super_xxx` methods comprise the default behavior and are
 242             // not meant to be overridden.
 243
 244             fn super_body(
 245                 &mut self,
 246                 body: &$($mutability)? Body<'tcx>,
 247             ) {
 248                 let span = body.span;
 249                 if let Some(gen) = &$($mutability)? body.generator {
 250                     if let Some(yield_ty) = $(& $mutability)? gen.yield_ty {
 251                         self.visit_ty(
 252                             yield_ty,
 253                             TyContext::YieldTy(SourceInfo::outermost(span))
 254                         );
 255                     }
 256                 }
 257
 258                 // for best performance, we want to use an iterator rather
 259                 // than a for-loop, to avoid calling `body::Body::invalidate` for
 260                 // each basic block.
 261                 macro_rules! basic_blocks {
 262                     (mut) => (body.basic_blocks_mut().iter_enumerated_mut());
 263                     () => (body.basic_blocks().iter_enumerated());
 264                 }
 265                 for (bb, data) in basic_blocks!($($mutability)?) {
 266                     self.visit_basic_block_data(bb, data);
 267                 }
 268
 269                 for scope in &$($mutability)? body.source_scopes {
 270                     self.visit_source_scope_data(scope);
 271                 }
 272
 273                 self.visit_ty(
 274                     $(& $mutability)? body.return_ty(),
 275                     TyContext::ReturnTy(SourceInfo::outermost(body.span))
 276                 );
 277
 278                 for local in body.local_decls.indices() {
 279                     self.visit_local_decl(local, & $($mutability)? body.local_decls[local]);
 280                 }
 281
 282                 macro_rules! type_annotations {
 283                     (mut) => (body.user_type_annotations.iter_enumerated_mut());
 284                     () => (body.user_type_annotations.iter_enumerated());
 285                 }
 286
 287                 for (index, annotation) in type_annotations!($($mutability)?) {
 288                     self.visit_user_type_annotation(
 289                         index, annotation
 290                     );
 291                 }
 292
 293                 for var_debug_info in &$($mutability)? body.var_debug_info {
 294                     self.visit_var_debug_info(var_debug_info);
 295                 }
 296
 297                 self.visit_span(&$($mutability)? body.span);
 298
 299                 for const_ in &$($mutability)? body.required_consts {
 300                     let location = START_BLOCK.start_location();
 301                     self.visit_constant(const_, location);
 302                 }
 303             }
 304
 305             fn super_basic_block_data(&mut self,
 306                                       block: BasicBlock,
 307                                       data: & $($mutability)? BasicBlockData<'tcx>) {
 308                 let BasicBlockData {
 309                     statements,
 310                     terminator,
 311                     is_cleanup: _
 312                 } = data;
 313
 314                 let mut index = 0;
 315                 for statement in statements {
 316                     let location = Location { block, statement_index: index };
 317                     self.visit_statement(statement, location);
 318                     index += 1;
 319                 }
 320
 321                 if let Some(terminator) = terminator {
 322                     let location = Location { block, statement_index: index };
 323                     self.visit_terminator(terminator, location);
 324                 }
 325             }
 326
 327             fn super_source_scope_data(
 328                 &mut self,
 329                 scope_data: & $($mutability)? SourceScopeData<'tcx>,
 330             ) {
 331                 let SourceScopeData {
 332                     span,
 333                     parent_scope,
 334                     inlined,
 335                     inlined_parent_scope,
 336                     local_data: _,
 337                 } = scope_data;
 338
 339                 self.visit_span(span);
 340                 if let Some(parent_scope) = parent_scope {
 341                     self.visit_source_scope(parent_scope);
 342                 }
 343                 if let Some((callee, callsite_span)) = inlined {
 344                     let location = START_BLOCK.start_location();
 345
 346                     self.visit_span(callsite_span);
 347
 348                     let ty::Instance { def: callee_def, substs: callee_substs } = callee;
 349                     match callee_def {
 350                         ty::InstanceDef::Item(_def_id) => {}
 351
 352                         ty::InstanceDef::Intrinsic(_def_id) |
 353                         ty::InstanceDef::VtableShim(_def_id) |
 354                         ty::InstanceDef::ReifyShim(_def_id) |
 355                         ty::InstanceDef::Virtual(_def_id, _) |
 356                         ty::InstanceDef::ClosureOnceShim { call_once: _def_id, track_caller: _ } |
 357                         ty::InstanceDef::DropGlue(_def_id, None) => {}
 358
 359                         ty::InstanceDef::FnPtrShim(_def_id, ty) |
 360                         ty::InstanceDef::DropGlue(_def_id, Some(ty)) |
 361                         ty::InstanceDef::CloneShim(_def_id, ty) => {
 362                             // FIXME(eddyb) use a better `TyContext` here.
 363                             self.visit_ty($(& $mutability)? *ty, TyContext::Location(location));
 364                         }
 365                     }
 366                     self.visit_substs(callee_substs, location);
 367                 }
 368                 if let Some(inlined_parent_scope) = inlined_parent_scope {
 369                     self.visit_source_scope(inlined_parent_scope);
 370                 }
 371             }
 372
 373             fn super_statement(&mut self,
 374                                statement: & $($mutability)? Statement<'tcx>,
 375                                location: Location) {
 376                 let Statement {
 377                     source_info,
 378                     kind,
 379                 } = statement;
 380
 381                 self.visit_source_info(source_info);
 382                 match kind {
 383                     StatementKind::Assign(
 384                         box(ref $($mutability)? place, ref $($mutability)? rvalue)
 385                     ) => {
 386                         self.visit_assign(place, rvalue, location);
 387                     }
 388                     StatementKind::FakeRead(box (_, place)) => {
 389                         self.visit_place(
 390                             place,
 391                             PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect),
 392                             location
 393                         );
 394                     }
 395                     StatementKind::SetDiscriminant { place, .. } => {
 396                         self.visit_place(
 397                             place,
 398                             PlaceContext::MutatingUse(MutatingUseContext::SetDiscriminant),
 399                             location
 400                         );
 401                     }
 402                     StatementKind::Deinit(place) => {
 403                         self.visit_place(
 404                             place,
 405                             PlaceContext::MutatingUse(MutatingUseContext::Deinit),
 406                             location
 407                         )
 408                     }
 409                     StatementKind::StorageLive(local) => {
 410                         self.visit_local(
 411                             local,
 412                             PlaceContext::NonUse(NonUseContext::StorageLive),
 413                             location
 414                         );
 415                     }
 416                     StatementKind::StorageDead(local) => {
 417                         self.visit_local(
 418                             local,
 419                             PlaceContext::NonUse(NonUseContext::StorageDead),
 420                             location
 421                         );
 422                     }
 423                     StatementKind::Retag(kind, place) => {
 424                         self.visit_retag(kind, place, location);
 425                     }
 426                     StatementKind::AscribeUserType(
 427                         box(ref $($mutability)? place, ref $($mutability)? user_ty),
 428                         variance
 429                     ) => {
 430                         self.visit_ascribe_user_ty(place, variance, user_ty, location);
 431                     }
 432                     StatementKind::Coverage(coverage) => {
 433                         self.visit_coverage(
 434                             coverage,
 435                             location
 436                         )
 437                     }
 438                     StatementKind::CopyNonOverlapping(box crate::mir::CopyNonOverlapping{
 439                       ref $($mutability)? src,
 440                       ref $($mutability)? dst,
 441                       ref $($mutability)? count,
 442                     }) => {
 443                       self.visit_operand(src, location);
 444                       self.visit_operand(dst, location);
 445                       self.visit_operand(count, location)
 446                     }
 447                     StatementKind::Nop => {}
 448                 }
 449             }
 450
 451             fn super_assign(&mut self,
 452                             place: &$($mutability)? Place<'tcx>,
 453                             rvalue: &$($mutability)? Rvalue<'tcx>,
 454                             location: Location) {
 455                 self.visit_place(
 456                     place,
 457                     PlaceContext::MutatingUse(MutatingUseContext::Store),
 458                     location
 459                 );
 460                 self.visit_rvalue(rvalue, location);
 461             }
 462
 463             fn super_terminator(&mut self,
 464                                 terminator: &$($mutability)? Terminator<'tcx>,
 465                                 location: Location) {
 466                 let Terminator { source_info, kind } = terminator;
 467
 468                 self.visit_source_info(source_info);
 469                 match kind {
 470                     TerminatorKind::Goto { .. } |
 471                     TerminatorKind::Resume |
 472                     TerminatorKind::Abort |
 473                     TerminatorKind::GeneratorDrop |
 474                     TerminatorKind::Unreachable |
 475                     TerminatorKind::FalseEdge { .. } |
 476                     TerminatorKind::FalseUnwind { .. } => {
 477                     }
 478
 479                     TerminatorKind::Return => {
 480                         // `return` logically moves from the return place `_0`. Note that the place
 481                         // cannot be changed by any visitor, though.
 482                         let $($mutability)? local = RETURN_PLACE;
 483                         self.visit_local(
 484                             & $($mutability)? local,
 485                             PlaceContext::NonMutatingUse(NonMutatingUseContext::Move),
 486                             location,
 487                         );
 488
 489                         assert_eq!(
 490                             local,
 491                             RETURN_PLACE,
 492                             "`MutVisitor` tried to mutate return place of `return` terminator"
 493                         );
 494                     }
 495
 496                     TerminatorKind::SwitchInt {
 497                         discr,
 498                         switch_ty,
 499                         targets: _
 500                     } => {
 501                         self.visit_operand(discr, location);
 502                         self.visit_ty($(& $mutability)? *switch_ty, TyContext::Location(location));
 503                     }
 504
 505                     TerminatorKind::Drop {
 506                         place,
 507                         target: _,
 508                         unwind: _,
 509                     } => {
 510                         self.visit_place(
 511                             place,
 512                             PlaceContext::MutatingUse(MutatingUseContext::Drop),
 513                             location
 514                         );
 515                     }
 516
 517                     TerminatorKind::DropAndReplace {
 518                         place,
 519                         value,
 520                         target: _,
 521                         unwind: _,
 522                     } => {
 523                         self.visit_place(
 524                             place,
 525                             PlaceContext::MutatingUse(MutatingUseContext::Drop),
 526                             location
 527                         );
 528                         self.visit_operand(value, location);
 529                     }
 530
 531                     TerminatorKind::Call {
 532                         func,
 533                         args,
 534                         destination,
 535                         cleanup: _,
 536                         from_hir_call: _,
 537                         fn_span: _
 538                     } => {
 539                         self.visit_operand(func, location);
 540                         for arg in args {
 541                             self.visit_operand(arg, location);
 542                         }
 543                         if let Some((destination, _)) = destination {
 544                             self.visit_place(
 545                                 destination,
 546                                 PlaceContext::MutatingUse(MutatingUseContext::Call),
 547                                 location
 548                             );
 549                         }
 550                     }
 551
 552                     TerminatorKind::Assert {
 553                         cond,
 554                         expected: _,
 555                         msg,
 556                         target: _,
 557                         cleanup: _,
 558                     } => {
 559                         self.visit_operand(cond, location);
 560                         self.visit_assert_message(msg, location);
 561                     }
 562
 563                     TerminatorKind::Yield {
 564                         value,
 565                         resume: _,
 566                         resume_arg,
 567                         drop: _,
 568                     } => {
 569                         self.visit_operand(value, location);
 570                         self.visit_place(
 571                             resume_arg,
 572                             PlaceContext::MutatingUse(MutatingUseContext::Yield),
 573                             location,
 574                         );
 575                     }
 576
 577                     TerminatorKind::InlineAsm {
 578                         template: _,
 579                         operands,
 580                         options: _,
 581                         line_spans: _,
 582                         destination: _,
 583                         cleanup: _,
 584                     } => {
 585                         for op in operands {
 586                             match op {
 587                                 InlineAsmOperand::In { value, .. } => {
 588                                     self.visit_operand(value, location);
 589                                 }
 590                                 InlineAsmOperand::Out { place: Some(place), .. } => {
 591                                     self.visit_place(
 592                                         place,
 593                                         PlaceContext::MutatingUse(MutatingUseContext::AsmOutput),
 594                                         location,
 595                                     );
 596                                 }
 597                                 InlineAsmOperand::InOut { in_value, out_place, .. } => {
 598                                     self.visit_operand(in_value, location);
 599                                     if let Some(out_place) = out_place {
 600                                         self.visit_place(
 601                                             out_place,
 602                                             PlaceContext::MutatingUse(MutatingUseContext::AsmOutput),
 603                                             location,
 604                                         );
 605                                     }
 606                                 }
 607                                 InlineAsmOperand::Const { value }
 608                                 | InlineAsmOperand::SymFn { value } => {
 609                                     self.visit_constant(value, location);
 610                                 }
 611                                 InlineAsmOperand::Out { place: None, .. }
 612                                 | InlineAsmOperand::SymStatic { def_id: _ } => {}
 613                             }
 614                         }
 615                     }
 616                 }
 617             }
 618
 619             fn super_assert_message(&mut self,
 620                                     msg: & $($mutability)? AssertMessage<'tcx>,
 621                                     location: Location) {
 622                 use crate::mir::AssertKind::*;
 623                 match msg {
 624                     BoundsCheck { len, index } => {
 625                         self.visit_operand(len, location);
 626                         self.visit_operand(index, location);
 627                     }
 628                     Overflow(_, l, r) => {
 629                         self.visit_operand(l, location);
 630                         self.visit_operand(r, location);
 631                     }
 632                     OverflowNeg(op) | DivisionByZero(op) | RemainderByZero(op) => {
 633                         self.visit_operand(op, location);
 634                     }
 635                     ResumedAfterReturn(_) | ResumedAfterPanic(_) => {
 636                         // Nothing to visit
 637                     }
 638                 }
 639             }
 640
 641             fn super_rvalue(&mut self,
 642                             rvalue: & $($mutability)? Rvalue<'tcx>,
 643                             location: Location) {
 644                 match rvalue {
 645                     Rvalue::Use(operand) => {
 646                         self.visit_operand(operand, location);
 647                     }
 648
 649                     Rvalue::Repeat(value, _) => {
 650                         self.visit_operand(value, location);
 651                     }
 652
 653                     Rvalue::ThreadLocalRef(_) => {}
 654
 655                     Rvalue::Ref(r, bk, path) => {
 656                         self.visit_region($(& $mutability)? *r, location);
 657                         let ctx = match bk {
 658                             BorrowKind::Shared => PlaceContext::NonMutatingUse(
 659                                 NonMutatingUseContext::SharedBorrow
 660                             ),
 661                             BorrowKind::Shallow => PlaceContext::NonMutatingUse(
 662                                 NonMutatingUseContext::ShallowBorrow
 663                             ),
 664                             BorrowKind::Unique => PlaceContext::NonMutatingUse(
 665                                 NonMutatingUseContext::UniqueBorrow
 666                             ),
 667                             BorrowKind::Mut { .. } =>
 668                                 PlaceContext::MutatingUse(MutatingUseContext::Borrow),
 669                         };
 670                         self.visit_place(path, ctx, location);
 671                     }
 672
 673                     Rvalue::AddressOf(m, path) => {
 674                         let ctx = match m {
 675                             Mutability::Mut => PlaceContext::MutatingUse(
 676                                 MutatingUseContext::AddressOf
 677                             ),
 678                             Mutability::Not => PlaceContext::NonMutatingUse(
 679                                 NonMutatingUseContext::AddressOf
 680                             ),
 681                         };
 682                         self.visit_place(path, ctx, location);
 683                     }
 684
 685                     Rvalue::Len(path) => {
 686                         self.visit_place(
 687                             path,
 688                             PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect),
 689                             location
 690                         );
 691                     }
 692
 693                     Rvalue::Cast(_cast_kind, operand, ty) => {
 694                         self.visit_operand(operand, location);
 695                         self.visit_ty($(& $mutability)? *ty, TyContext::Location(location));
 696                     }
 697
 698                     Rvalue::BinaryOp(_bin_op, box(lhs, rhs))
 699                     | Rvalue::CheckedBinaryOp(_bin_op, box(lhs, rhs)) => {
 700                         self.visit_operand(lhs, location);
 701                         self.visit_operand(rhs, location);
 702                     }
 703
 704                     Rvalue::UnaryOp(_un_op, op) => {
 705                         self.visit_operand(op, location);
 706                     }
 707
 708                     Rvalue::Discriminant(place) => {
 709                         self.visit_place(
 710                             place,
 711                             PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect),
 712                             location
 713                         );
 714                     }
 715
 716                     Rvalue::NullaryOp(_op, ty) => {
 717                         self.visit_ty($(& $mutability)? *ty, TyContext::Location(location));
 718                     }
 719
 720                     Rvalue::Aggregate(kind, operands) => {
 721                         let kind = &$($mutability)? **kind;
 722                         match kind {
 723                             AggregateKind::Array(ty) => {
 724                                 self.visit_ty($(& $mutability)? *ty, TyContext::Location(location));
 725                             }
 726                             AggregateKind::Tuple => {
 727                             }
 728                             AggregateKind::Adt(
 729                                 _adt_def,
 730                                 _variant_index,
 731                                 substs,
 732                                 _user_substs,
 733                                 _active_field_index
 734                             ) => {
 735                                 self.visit_substs(substs, location);
 736                             }
 737                             AggregateKind::Closure(
 738                                 _,
 739                                 closure_substs
 740                             ) => {
 741                                 self.visit_substs(closure_substs, location);
 742                             }
 743                             AggregateKind::Generator(
 744                                 _,
 745                                 generator_substs,
 746                                 _movability,
 747                             ) => {
 748                                 self.visit_substs(generator_substs, location);
 749                             }
 750                         }
 751
 752                         for operand in operands {
 753                             self.visit_operand(operand, location);
 754                         }
 755                     }
 756
 757                     Rvalue::ShallowInitBox(operand, ty) => {
 758                         self.visit_operand(operand, location);
 759                         self.visit_ty($(& $mutability)? *ty, TyContext::Location(location));
 760                     }
 761                 }
 762             }
 763
 764             fn super_operand(&mut self,
 765                              operand: & $($mutability)? Operand<'tcx>,
 766                              location: Location) {
 767                 match operand {
 768                     Operand::Copy(place) => {
 769                         self.visit_place(
 770                             place,
 771                             PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
 772                             location
 773                         );
 774                     }
 775                     Operand::Move(place) => {
 776                         self.visit_place(
 777                             place,
 778                             PlaceContext::NonMutatingUse(NonMutatingUseContext::Move),
 779                             location
 780                         );
 781                     }
 782                     Operand::Constant(constant) => {
 783                         self.visit_constant(constant, location);
 784                     }
 785                 }
 786             }
 787
 788             fn super_ascribe_user_ty(&mut self,
 789                                      place: & $($mutability)? Place<'tcx>,
 790                                      _variance: & $($mutability)? ty::Variance,
 791                                      user_ty: & $($mutability)? UserTypeProjection,
 792                                      location: Location) {
 793                 self.visit_place(
 794                     place,
 795                     PlaceContext::NonUse(NonUseContext::AscribeUserTy),
 796                     location
 797                 );
 798                 self.visit_user_type_projection(user_ty);
 799             }
 800
 801             fn super_coverage(&mut self,
 802                               _coverage: & $($mutability)? Coverage,
 803                               _location: Location) {
 804             }
 805
 806             fn super_retag(&mut self,
 807                            _kind: & $($mutability)? RetagKind,
 808                            place: & $($mutability)? Place<'tcx>,
 809                            location: Location) {
 810                 self.visit_place(
 811                     place,
 812                     PlaceContext::MutatingUse(MutatingUseContext::Retag),
 813                     location,
 814                 );
 815             }
 816
 817             fn super_local_decl(&mut self,
 818                                 local: Local,
 819                                 local_decl: & $($mutability)? LocalDecl<'tcx>) {
 820                 let LocalDecl {
 821                     mutability: _,
 822                     ty,
 823                     user_ty,
 824                     source_info,
 825                     internal: _,
 826                     local_info: _,
 827                     is_block_tail: _,
 828                 } = local_decl;
 829
 830                 self.visit_ty($(& $mutability)? *ty, TyContext::LocalDecl {
 831                     local,
 832                     source_info: *source_info,
 833                 });
 834                 if let Some(user_ty) = user_ty {
 835                     for (user_ty, _) in & $($mutability)? user_ty.contents {
 836                         self.visit_user_type_projection(user_ty);
 837                     }
 838                 }
 839                 self.visit_source_info(source_info);
 840             }
 841
 842             fn super_var_debug_info(&mut self,
 843                                     var_debug_info: & $($mutability)? VarDebugInfo<'tcx>) {
 844                 let VarDebugInfo {
 845                     name: _,
 846                     source_info,
 847                     value,
 848                 } = var_debug_info;
 849
 850                 self.visit_source_info(source_info);
 851                 let location = START_BLOCK.start_location();
 852                 match value {
 853                     VarDebugInfoContents::Const(c) => self.visit_constant(c, location),
 854                     VarDebugInfoContents::Place(place) =>
 855                         self.visit_place(
 856                             place,
 857                             PlaceContext::NonUse(NonUseContext::VarDebugInfo),
 858                             location
 859                         ),
 860                 }
 861             }
 862
 863             #[allow(rustc::pass_by_value)]
 864             fn super_source_scope(&mut self,
 865                                       _scope: & $($mutability)? SourceScope) {
 866             }
 867
 868             fn super_constant(&mut self,
 869                               constant: & $($mutability)? Constant<'tcx>,
 870                               location: Location) {
 871                 let Constant {
 872                     span,
 873                     user_ty,
 874                     literal,
 875                 } = constant;
 876
 877                 self.visit_span(span);
 878                 drop(user_ty); // no visit method for this
 879                 match literal {
 880                     ConstantKind::Ty(ct) => self.visit_const($(& $mutability)? *ct, location),
 881                     ConstantKind::Val(_, ty) => self.visit_ty($(& $mutability)? *ty, TyContext::Location(location)),
 882                 }
 883             }
 884
 885             // The macro results in a false positive of sorts, where &mut Span
 886             // is fine, but &Span is not; just allow the lint.
 887             #[allow(rustc::pass_by_value)]
 888             fn super_span(&mut self, _span: & $($mutability)? Span) {
 889             }
 890
 891             fn super_source_info(&mut self, source_info: & $($mutability)? SourceInfo) {
 892                 let SourceInfo {
 893                     span,
 894                     scope,
 895                 } = source_info;
 896
 897                 self.visit_span(span);
 898                 self.visit_source_scope(scope);
 899             }
 900
 901             fn super_user_type_projection(
 902                 &mut self,
 903                 _ty: & $($mutability)? UserTypeProjection,
 904             ) {
 905             }
 906
 907             fn super_user_type_annotation(
 908                 &mut self,
 909                 _index: UserTypeAnnotationIndex,
 910                 ty: & $($mutability)? CanonicalUserTypeAnnotation<'tcx>,
 911             ) {
 912                 self.visit_span(& $($mutability)? ty.span);
 913                 self.visit_ty($(& $mutability)? ty.inferred_ty, TyContext::UserTy(ty.span));
 914             }
 915
 916             fn super_ty(&mut self, _ty: $(& $mutability)? Ty<'tcx>) {
 917             }
 918
 919             fn super_region(&mut self, _region: $(& $mutability)? ty::Region<'tcx>) {
 920             }
 921
 922             fn super_const(&mut self, _const: $(& $mutability)? ty::Const<'tcx>) {
 923             }
 924
 925             fn super_substs(&mut self, _substs: & $($mutability)? SubstsRef<'tcx>) {
 926             }
 927
 928             // Convenience methods
 929
 930             fn visit_location(
 931                 &mut self,
 932                 body: &$($mutability)? Body<'tcx>,
 933                 location: Location
 934             ) {
 935                 macro_rules! basic_blocks {
 936                     (mut) => (body.basic_blocks_mut());
 937                     () => (body.basic_blocks());
 938                 }
 939                 let basic_block = & $($mutability)? basic_blocks!($($mutability)?)[location.block];
 940                 if basic_block.statements.len() == location.statement_index {
 941                     if let Some(ref $($mutability)? terminator) = basic_block.terminator {
 942                         self.visit_terminator(terminator, location)
 943                     }
 944                 } else {
 945                     let statement = & $($mutability)?
 946                         basic_block.statements[location.statement_index];
 947                     self.visit_statement(statement, location)
 948                 }
 949             }
 950         }
 951     }
 952 }
 953
 954 macro_rules! visit_place_fns {
 955     (mut) => {
 956         fn tcx<'a>(&'a self) -> TyCtxt<'tcx>;
 957
 958         fn super_place(
 959             &mut self,
 960             place: &mut Place<'tcx>,
 961             context: PlaceContext,
 962             location: Location,
 963         ) {
 964             self.visit_local(&mut place.local, context, location);
 965
 966             if let Some(new_projection) = self.process_projection(&place.projection, location) {
 967                 place.projection = self.tcx().intern_place_elems(&new_projection);
 968             }
 969         }
 970
 971         fn process_projection<'a>(
 972             &mut self,
 973             projection: &'a [PlaceElem<'tcx>],
 974             location: Location,
 975         ) -> Option<Vec<PlaceElem<'tcx>>> {
 976             let mut projection = Cow::Borrowed(projection);
 977
 978             for i in 0..projection.len() {
 979                 if let Some(&elem) = projection.get(i) {
 980                     if let Some(elem) = self.process_projection_elem(elem, location) {
 981                         // This converts the borrowed projection into `Cow::Owned(_)` and returns a
 982                         // clone of the projection so we can mutate and reintern later.
 983                         let vec = projection.to_mut();
 984                         vec[i] = elem;
 985                     }
 986                 }
 987             }
 988
 989             match projection {
 990                 Cow::Borrowed(_) => None,
 991                 Cow::Owned(vec) => Some(vec),
 992             }
 993         }
 994
 995         fn process_projection_elem(
 996             &mut self,
 997             elem: PlaceElem<'tcx>,
 998             location: Location,
 999         ) -> Option<PlaceElem<'tcx>> {
1000             match elem {
1001                 PlaceElem::Index(local) => {
1002                     let mut new_local = local;
1003                     self.visit_local(
1004                         &mut new_local,
1005                         PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
1006                         location,
1007                     );
1008
1009                     if new_local == local { None } else { Some(PlaceElem::Index(new_local)) }
1010                 }
1011                 PlaceElem::Field(field, ty) => {
1012                     let mut new_ty = ty;
1013                     self.visit_ty(&mut new_ty, TyContext::Location(location));
1014                     if ty != new_ty { Some(PlaceElem::Field(field, new_ty)) } else { None }
1015                 }
1016                 PlaceElem::Deref
1017                 | PlaceElem::ConstantIndex { .. }
1018                 | PlaceElem::Subslice { .. }
1019                 | PlaceElem::Downcast(..) => None,
1020             }
1021         }
1022     };
1023
1024     () => {
1025         fn visit_projection(
1026             &mut self,
1027             place_ref: PlaceRef<'tcx>,
1028             context: PlaceContext,
1029             location: Location,
1030         ) {
1031             self.super_projection(place_ref, context, location);
1032         }
1033
1034         fn visit_projection_elem(
1035             &mut self,
1036             local: Local,
1037             proj_base: &[PlaceElem<'tcx>],
1038             elem: PlaceElem<'tcx>,
1039             context: PlaceContext,
1040             location: Location,
1041         ) {
1042             self.super_projection_elem(local, proj_base, elem, context, location);
1043         }
1044
1045         fn super_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) {
1046             let mut context = context;
1047
1048             if !place.projection.is_empty() {
1049                 if context.is_use() {
1050                     // ^ Only change the context if it is a real use, not a "use" in debuginfo.
1051                     context = if context.is_mutating_use() {
1052                         PlaceContext::MutatingUse(MutatingUseContext::Projection)
1053                     } else {
1054                         PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection)
1055                     };
1056                 }
1057             }
1058
1059             self.visit_local(&place.local, context, location);
1060
1061             self.visit_projection(place.as_ref(), context, location);
1062         }
1063
1064         fn super_projection(
1065             &mut self,
1066             place_ref: PlaceRef<'tcx>,
1067             context: PlaceContext,
1068             location: Location,
1069         ) {
1070             // FIXME: Use PlaceRef::iter_projections, once that exists.
1071             let mut cursor = place_ref.projection;
1072             while let &[ref proj_base @ .., elem] = cursor {
1073                 cursor = proj_base;
1074                 self.visit_projection_elem(place_ref.local, cursor, elem, context, location);
1075             }
1076         }
1077
1078         fn super_projection_elem(
1079             &mut self,
1080             _local: Local,
1081             _proj_base: &[PlaceElem<'tcx>],
1082             elem: PlaceElem<'tcx>,
1083             _context: PlaceContext,
1084             location: Location,
1085         ) {
1086             match elem {
1087                 ProjectionElem::Field(_field, ty) => {
1088                     self.visit_ty(ty, TyContext::Location(location));
1089                 }
1090                 ProjectionElem::Index(local) => {
1091                     self.visit_local(
1092                         &local,
1093                         PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy),
1094                         location,
1095                     );
1096                 }
1097                 ProjectionElem::Deref
1098                 | ProjectionElem::Subslice { from: _, to: _, from_end: _ }
1099                 | ProjectionElem::ConstantIndex { offset: _, min_length: _, from_end: _ }
1100                 | ProjectionElem::Downcast(_, _) => {}
1101             }
1102         }
1103     };
1104 }
1105
1106 make_mir_visitor!(Visitor,);
1107 make_mir_visitor!(MutVisitor, mut);
1108
1109 pub trait MirVisitable<'tcx> {
1110     fn apply(&self, location: Location, visitor: &mut dyn Visitor<'tcx>);
1111 }
1112
1113 impl<'tcx> MirVisitable<'tcx> for Statement<'tcx> {
1114     fn apply(&self, location: Location, visitor: &mut dyn Visitor<'tcx>) {
1115         visitor.visit_statement(self, location)
1116     }
1117 }
1118
1119 impl<'tcx> MirVisitable<'tcx> for Terminator<'tcx> {
1120     fn apply(&self, location: Location, visitor: &mut dyn Visitor<'tcx>) {
1121         visitor.visit_terminator(self, location)
1122     }
1123 }
1124
1125 impl<'tcx> MirVisitable<'tcx> for Option<Terminator<'tcx>> {
1126     fn apply(&self, location: Location, visitor: &mut dyn Visitor<'tcx>) {
1127         visitor.visit_terminator(self.as_ref().unwrap(), location)
1128     }
1129 }
1130
1131 /// Extra information passed to `visit_ty` and friends to give context
1132 /// about where the type etc appears.
1133 #[derive(Debug)]
1134 pub enum TyContext {
1135     LocalDecl {
1136         /// The index of the local variable we are visiting.
1137         local: Local,
1138
1139         /// The source location where this local variable was declared.
1140         source_info: SourceInfo,
1141     },
1142
1143     /// The inferred type of a user type annotation.
1144     UserTy(Span),
1145
1146     /// The return type of the function.
1147     ReturnTy(SourceInfo),
1148
1149     YieldTy(SourceInfo),
1150
1151     /// A type found at some location.
1152     Location(Location),
1153 }
1154
1155 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
1156 pub enum NonMutatingUseContext {
1157     /// Being inspected in some way, like loading a len.
1158     Inspect,
1159     /// Consumed as part of an operand.
1160     Copy,
1161     /// Consumed as part of an operand.
1162     Move,
1163     /// Shared borrow.
1164     SharedBorrow,
1165     /// Shallow borrow.
1166     ShallowBorrow,
1167     /// Unique borrow.
1168     UniqueBorrow,
1169     /// AddressOf for *const pointer.
1170     AddressOf,
1171     /// Used as base for another place, e.g., `x` in `x.y`. Will not mutate the place.
1172     /// For example, the projection `x.y` is not marked as a mutation in these cases:
1173     ///
1174     ///     z = x.y;
1175     ///     f(&x.y);
1176     ///
1177     Projection,
1178 }
1179
1180 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
1181 pub enum MutatingUseContext {
1182     /// Appears as LHS of an assignment.
1183     Store,
1184     /// Appears on `SetDiscriminant`
1185     SetDiscriminant,
1186     /// Appears on `Deinit`
1187     Deinit,
1188     /// Output operand of an inline assembly block.
1189     AsmOutput,
1190     /// Destination of a call.
1191     Call,
1192     /// Destination of a yield.
1193     Yield,
1194     /// Being dropped.
1195     Drop,
1196     /// Mutable borrow.
1197     Borrow,
1198     /// AddressOf for *mut pointer.
1199     AddressOf,
1200     /// Used as base for another place, e.g., `x` in `x.y`. Could potentially mutate the place.
1201     /// For example, the projection `x.y` is marked as a mutation in these cases:
1202     ///
1203     ///     x.y = ...;
1204     ///     f(&mut x.y);
1205     ///
1206     Projection,
1207     /// Retagging, a "Stacked Borrows" shadow state operation
1208     Retag,
1209 }
1210
1211 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
1212 pub enum NonUseContext {
1213     /// Starting a storage live range.
1214     StorageLive,
1215     /// Ending a storage live range.
1216     StorageDead,
1217     /// User type annotation assertions for NLL.
1218     AscribeUserTy,
1219     /// The data of a user variable, for debug info.
1220     VarDebugInfo,
1221 }
1222
1223 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
1224 pub enum PlaceContext {
1225     NonMutatingUse(NonMutatingUseContext),
1226     MutatingUse(MutatingUseContext),
1227     NonUse(NonUseContext),
1228 }
1229
1230 impl PlaceContext {
1231     /// Returns `true` if this place context represents a drop.
1232     #[inline]
1233     pub fn is_drop(&self) -> bool {
1234         matches!(self, PlaceContext::MutatingUse(MutatingUseContext::Drop))
1235     }
1236
1237     /// Returns `true` if this place context represents a borrow.
1238     pub fn is_borrow(&self) -> bool {
1239         matches!(
1240             self,
1241             PlaceContext::NonMutatingUse(
1242                 NonMutatingUseContext::SharedBorrow
1243                     | NonMutatingUseContext::ShallowBorrow
1244                     | NonMutatingUseContext::UniqueBorrow
1245             ) | PlaceContext::MutatingUse(MutatingUseContext::Borrow)
1246         )
1247     }
1248
1249     /// Returns `true` if this place context represents a storage live or storage dead marker.
1250     #[inline]
1251     pub fn is_storage_marker(&self) -> bool {
1252         matches!(
1253             self,
1254             PlaceContext::NonUse(NonUseContext::StorageLive | NonUseContext::StorageDead)
1255         )
1256     }
1257
1258     /// Returns `true` if this place context represents a use that potentially changes the value.
1259     #[inline]
1260     pub fn is_mutating_use(&self) -> bool {
1261         matches!(self, PlaceContext::MutatingUse(..))
1262     }
1263
1264     /// Returns `true` if this place context represents a use.
1265     #[inline]
1266     pub fn is_use(&self) -> bool {
1267         !matches!(self, PlaceContext::NonUse(..))
1268     }
1269
1270     /// Returns `true` if this place context represents an assignment statement.
1271     pub fn is_place_assignment(&self) -> bool {
1272         matches!(
1273             self,
1274             PlaceContext::MutatingUse(
1275                 MutatingUseContext::Store
1276                     | MutatingUseContext::Call
1277                     | MutatingUseContext::AsmOutput,
1278             )
1279         )
1280     }
1281 }