src/librustc_passes/rvalue_promotion.rs

   1 // Verifies that the types and values of const and static items
   2 // are safe. The rules enforced by this module are:
   3 //
   4 // - For each *mutable* static item, it checks that its **type**:
   5 //     - doesn't have a destructor
   6 //     - doesn't own a box
   7 //
   8 // - For each *immutable* static item, it checks that its **value**:
   9 //       - doesn't own a box
  10 //       - doesn't contain a struct literal or a call to an enum variant / struct constructor where
  11 //           - the type of the struct/enum has a dtor
  12 //
  13 // Rules Enforced Elsewhere:
  14 // - It's not possible to take the address of a static item with unsafe interior. This is enforced
  15 // by borrowck::gather_loans
  16
  17 use rustc::ty::cast::CastKind;
  18 use rustc::hir::def::{Def, CtorKind};
  19 use rustc::hir::def_id::DefId;
  20 use rustc::middle::expr_use_visitor as euv;
  21 use rustc::middle::mem_categorization as mc;
  22 use rustc::middle::mem_categorization::Categorization;
  23 use rustc::ty::{self, Ty, TyCtxt};
  24 use rustc::ty::query::Providers;
  25 use rustc::ty::subst::Substs;
  26 use rustc::util::nodemap::{ItemLocalSet, NodeSet};
  27 use rustc::hir;
  28 use rustc_data_structures::sync::Lrc;
  29 use syntax::ast;
  30 use syntax_pos::{Span, DUMMY_SP};
  31 use log::debug;
  32 use Promotability::*;
  33 use std::ops::{BitAnd, BitAndAssign, BitOr};
  34
  35 pub fn provide(providers: &mut Providers<'_>) {
  36     *providers = Providers {
  37         rvalue_promotable_map,
  38         const_is_rvalue_promotable_to_static,
  39         ..*providers
  40     };
  41 }
  42
  43 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
  44     for &body_id in &tcx.hir().krate().body_ids {
  45         let def_id = tcx.hir().body_owner_def_id(body_id);
  46         tcx.const_is_rvalue_promotable_to_static(def_id);
  47     }
  48 }
  49
  50 fn const_is_rvalue_promotable_to_static<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
  51                                                   def_id: DefId)
  52                                                   -> bool
  53 {
  54     assert!(def_id.is_local());
  55
  56     let node_id = tcx.hir().as_local_node_id(def_id)
  57         .expect("rvalue_promotable_map invoked with non-local def-id");
  58     let body_id = tcx.hir().body_owned_by(node_id);
  59     let body_hir_id = tcx.hir().node_to_hir_id(body_id.node_id);
  60     tcx.rvalue_promotable_map(def_id).contains(&body_hir_id.local_id)
  61 }
  62
  63 fn rvalue_promotable_map<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
  64                                    def_id: DefId)
  65                                    -> Lrc<ItemLocalSet>
  66 {
  67     let outer_def_id = tcx.closure_base_def_id(def_id);
  68     if outer_def_id != def_id {
  69         return tcx.rvalue_promotable_map(outer_def_id);
  70     }
  71
  72     let mut visitor = CheckCrateVisitor {
  73         tcx,
  74         tables: &ty::TypeckTables::empty(None),
  75         in_fn: false,
  76         in_static: false,
  77         mut_rvalue_borrows: Default::default(),
  78         param_env: ty::ParamEnv::empty(),
  79         identity_substs: Substs::empty(),
  80         result: ItemLocalSet::default(),
  81     };
  82
  83     // `def_id` should be a `Body` owner
  84     let node_id = tcx.hir().as_local_node_id(def_id)
  85         .expect("rvalue_promotable_map invoked with non-local def-id");
  86     let body_id = tcx.hir().body_owned_by(node_id);
  87     let _ = visitor.check_nested_body(body_id);
  88
  89     Lrc::new(visitor.result)
  90 }
  91
  92 struct CheckCrateVisitor<'a, 'tcx: 'a> {
  93     tcx: TyCtxt<'a, 'tcx, 'tcx>,
  94     in_fn: bool,
  95     in_static: bool,
  96     mut_rvalue_borrows: NodeSet,
  97     param_env: ty::ParamEnv<'tcx>,
  98     identity_substs: &'tcx Substs<'tcx>,
  99     tables: &'a ty::TypeckTables<'tcx>,
 100     result: ItemLocalSet,
 101 }
 102
 103 #[must_use]
 104 #[derive(Debug, Clone, Copy, PartialEq)]
 105 enum Promotability {
 106     Promotable,
 107     NotPromotable
 108 }
 109
 110 impl BitAnd for Promotability {
 111     type Output = Self;
 112
 113     fn bitand(self, rhs: Self) -> Self {
 114         match (self, rhs) {
 115             (Promotable, Promotable) => Promotable,
 116             _ => NotPromotable,
 117         }
 118     }
 119 }
 120
 121 impl BitAndAssign for Promotability {
 122     fn bitand_assign(&mut self, rhs: Self) {
 123         *self = *self & rhs
 124     }
 125 }
 126
 127 impl BitOr for Promotability {
 128     type Output = Self;
 129
 130     fn bitor(self, rhs: Self) -> Self {
 131         match (self, rhs) {
 132             (NotPromotable, NotPromotable) => NotPromotable,
 133             _ => Promotable,
 134         }
 135     }
 136 }
 137
 138 impl<'a, 'gcx> CheckCrateVisitor<'a, 'gcx> {
 139     // Returns true iff all the values of the type are promotable.
 140     fn type_promotability(&mut self, ty: Ty<'gcx>) -> Promotability {
 141         debug!("type_promotability({})", ty);
 142
 143         if ty.is_freeze(self.tcx, self.param_env, DUMMY_SP) &&
 144             !ty.needs_drop(self.tcx, self.param_env) {
 145             Promotable
 146         } else {
 147             NotPromotable
 148         }
 149     }
 150
 151     fn handle_const_fn_call(
 152         &mut self,
 153         def_id: DefId,
 154     ) -> Promotability {
 155         if self.tcx.is_promotable_const_fn(def_id) {
 156             Promotable
 157         } else {
 158             NotPromotable
 159         }
 160     }
 161
 162     /// While the `ExprUseVisitor` walks, we will identify which
 163     /// expressions are borrowed, and insert their IDs into this
 164     /// table. Actually, we insert the "borrow-id", which is normally
 165     /// the ID of the expression being borrowed: but in the case of
 166     /// `ref mut` borrows, the `id` of the pattern is
 167     /// inserted. Therefore, later we remove that entry from the table
 168     /// and transfer it over to the value being matched. This will
 169     /// then prevent said value from being promoted.
 170     fn remove_mut_rvalue_borrow(&mut self, pat: &hir::Pat) -> bool {
 171         let mut any_removed = false;
 172         pat.walk(|p| {
 173             any_removed |= self.mut_rvalue_borrows.remove(&p.id);
 174             true
 175         });
 176         any_removed
 177     }
 178 }
 179
 180 impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
 181     fn check_nested_body(&mut self, body_id: hir::BodyId) -> Promotability {
 182         let item_id = self.tcx.hir().body_owner(body_id);
 183         let item_def_id = self.tcx.hir().local_def_id(item_id);
 184
 185         let outer_in_fn = self.in_fn;
 186         let outer_tables = self.tables;
 187         let outer_param_env = self.param_env;
 188         let outer_identity_substs = self.identity_substs;
 189
 190         self.in_fn = false;
 191         self.in_static = false;
 192
 193         match self.tcx.hir().body_owner_kind(item_id) {
 194             hir::BodyOwnerKind::Closure |
 195             hir::BodyOwnerKind::Fn => self.in_fn = true,
 196             hir::BodyOwnerKind::Static(_) => self.in_static = true,
 197             _ => {}
 198         };
 199
 200
 201         self.tables = self.tcx.typeck_tables_of(item_def_id);
 202         self.param_env = self.tcx.param_env(item_def_id);
 203         self.identity_substs = Substs::identity_for_item(self.tcx, item_def_id);
 204
 205         let body = self.tcx.hir().body(body_id);
 206
 207         let tcx = self.tcx;
 208         let param_env = self.param_env;
 209         let region_scope_tree = self.tcx.region_scope_tree(item_def_id);
 210         let tables = self.tables;
 211         euv::ExprUseVisitor::new(self, tcx, param_env, &region_scope_tree, tables, None)
 212             .consume_body(body);
 213
 214         let body_promotable = self.check_expr(&body.value);
 215         self.in_fn = outer_in_fn;
 216         self.tables = outer_tables;
 217         self.param_env = outer_param_env;
 218         self.identity_substs = outer_identity_substs;
 219         body_promotable
 220     }
 221
 222     fn check_stmt(&mut self, stmt: &'tcx hir::Stmt) -> Promotability {
 223         match stmt.node {
 224             hir::StmtKind::Local(ref local) => {
 225                 if self.remove_mut_rvalue_borrow(&local.pat) {
 226                     if let Some(init) = &local.init {
 227                         self.mut_rvalue_borrows.insert(init.id);
 228                     }
 229                 }
 230
 231                 if let Some(ref expr) = local.init {
 232                     let _ = self.check_expr(&expr);
 233                 }
 234                 NotPromotable
 235             }
 236             // Item statements are allowed
 237             hir::StmtKind::Item(..) => Promotable,
 238             hir::StmtKind::Expr(ref box_expr) |
 239             hir::StmtKind::Semi(ref box_expr) => {
 240                 let _ = self.check_expr(box_expr);
 241                 NotPromotable
 242             }
 243         }
 244     }
 245
 246     fn check_expr(&mut self, ex: &'tcx hir::Expr) -> Promotability {
 247         let node_ty = self.tables.node_type(ex.hir_id);
 248         let mut outer = check_expr_kind(self, ex, node_ty);
 249         outer &= check_adjustments(self, ex);
 250
 251         // Handle borrows on (or inside the autorefs of) this expression.
 252         if self.mut_rvalue_borrows.remove(&ex.id) {
 253             outer = NotPromotable
 254         }
 255
 256         if outer == Promotable {
 257             self.result.insert(ex.hir_id.local_id);
 258         }
 259         outer
 260     }
 261
 262     fn check_block(&mut self, block: &'tcx hir::Block) -> Promotability {
 263         let mut iter_result = Promotable;
 264         for index in block.stmts.iter() {
 265             iter_result &= self.check_stmt(index);
 266         }
 267         match block.expr {
 268             Some(ref box_expr) => iter_result & self.check_expr(&*box_expr),
 269             None => iter_result,
 270         }
 271     }
 272 }
 273
 274 /// This function is used to enforce the constraints on
 275 /// const/static items. It walks through the *value*
 276 /// of the item walking down the expression and evaluating
 277 /// every nested expression. If the expression is not part
 278 /// of a const/static item, it is qualified for promotion
 279 /// instead of producing errors.
 280 fn check_expr_kind<'a, 'tcx>(
 281     v: &mut CheckCrateVisitor<'a, 'tcx>,
 282     e: &'tcx hir::Expr, node_ty: Ty<'tcx>) -> Promotability {
 283
 284     let ty_result = match node_ty.sty {
 285         ty::Adt(def, _) if def.has_dtor(v.tcx) => {
 286             NotPromotable
 287         }
 288         _ => Promotable
 289     };
 290
 291     let node_result = match e.node {
 292         hir::ExprKind::Box(ref expr) => {
 293             let _ = v.check_expr(&expr);
 294             NotPromotable
 295         }
 296         hir::ExprKind::Unary(op, ref expr) => {
 297             let expr_promotability = v.check_expr(expr);
 298             if v.tables.is_method_call(e) || op == hir::UnDeref {
 299                 return NotPromotable;
 300             }
 301             expr_promotability
 302         }
 303         hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
 304             let lefty = v.check_expr(lhs);
 305             let righty = v.check_expr(rhs);
 306             if v.tables.is_method_call(e) {
 307                 return NotPromotable;
 308             }
 309             match v.tables.node_type(lhs.hir_id).sty {
 310                 ty::RawPtr(_) | ty::FnPtr(..) => {
 311                     assert!(op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne ||
 312                             op.node == hir::BinOpKind::Le || op.node == hir::BinOpKind::Lt ||
 313                             op.node == hir::BinOpKind::Ge || op.node == hir::BinOpKind::Gt);
 314
 315                     NotPromotable
 316                 }
 317                 _ => lefty & righty
 318             }
 319         }
 320         hir::ExprKind::Cast(ref from, _) => {
 321             let expr_promotability = v.check_expr(from);
 322             debug!("Checking const cast(id={})", from.id);
 323             match v.tables.cast_kinds().get(from.hir_id) {
 324                 None => {
 325                     v.tcx.sess.delay_span_bug(e.span, "no kind for cast");
 326                     NotPromotable
 327                 },
 328                 Some(&CastKind::PtrAddrCast) | Some(&CastKind::FnPtrAddrCast) => {
 329                     NotPromotable
 330                 }
 331                 _ => expr_promotability
 332             }
 333         }
 334         hir::ExprKind::Path(ref qpath) => {
 335             let def = v.tables.qpath_def(qpath, e.hir_id);
 336             match def {
 337                 Def::VariantCtor(..) | Def::StructCtor(..) |
 338                 Def::Fn(..) | Def::Method(..) | Def::SelfCtor(..) => Promotable,
 339
 340                 // References to a static that are themselves within a static
 341                 // are inherently promotable with the exception
 342                 //  of "#[thread_local]" statics, which may not
 343                 // outlive the current function
 344                 Def::Static(did, _) => {
 345
 346                     if v.in_static {
 347                         for attr in &v.tcx.get_attrs(did)[..] {
 348                             if attr.check_name("thread_local") {
 349                                 debug!("Reference to Static(id={:?}) is unpromotable \
 350                                        due to a #[thread_local] attribute", did);
 351                                 return NotPromotable;
 352                             }
 353                         }
 354                         Promotable
 355                     } else {
 356                         debug!("Reference to Static(id={:?}) is unpromotable as it is not \
 357                                referenced from a static", did);
 358                         NotPromotable
 359                     }
 360                 }
 361
 362                 Def::Const(did) |
 363                 Def::AssociatedConst(did) => {
 364                     let promotable = if v.tcx.trait_of_item(did).is_some() {
 365                         // Don't peek inside trait associated constants.
 366                         NotPromotable
 367                     } else if v.tcx.at(e.span).const_is_rvalue_promotable_to_static(did) {
 368                         Promotable
 369                     } else {
 370                         NotPromotable
 371                     };
 372                     // Just in case the type is more specific than the definition,
 373                     // e.g., impl associated const with type parameters, check it.
 374                     // Also, trait associated consts are relaxed by this.
 375                     promotable | v.type_promotability(node_ty)
 376                 }
 377                 _ => NotPromotable
 378             }
 379         }
 380         hir::ExprKind::Call(ref callee, ref hirvec) => {
 381             let mut call_result = v.check_expr(callee);
 382             for index in hirvec.iter() {
 383                 call_result &= v.check_expr(index);
 384             }
 385             let mut callee = &**callee;
 386             loop {
 387                 callee = match callee.node {
 388                     hir::ExprKind::Block(ref block, _) => match block.expr {
 389                         Some(ref tail) => &tail,
 390                         None => break
 391                     },
 392                     _ => break
 393                 };
 394             }
 395             // The callee is an arbitrary expression, it doesn't necessarily have a definition.
 396             let def = if let hir::ExprKind::Path(ref qpath) = callee.node {
 397                 v.tables.qpath_def(qpath, callee.hir_id)
 398             } else {
 399                 Def::Err
 400             };
 401             let def_result = match def {
 402                 Def::StructCtor(_, CtorKind::Fn) |
 403                 Def::VariantCtor(_, CtorKind::Fn) |
 404                 Def::SelfCtor(..) => Promotable,
 405                 Def::Fn(did) => v.handle_const_fn_call(did),
 406                 Def::Method(did) => {
 407                     match v.tcx.associated_item(did).container {
 408                         ty::ImplContainer(_) => v.handle_const_fn_call(did),
 409                         ty::TraitContainer(_) => NotPromotable,
 410                     }
 411                 }
 412                 _ => NotPromotable,
 413             };
 414             def_result & call_result
 415         }
 416         hir::ExprKind::MethodCall(ref _pathsegment, ref _span, ref hirvec) => {
 417             let mut method_call_result = Promotable;
 418             for index in hirvec.iter() {
 419                 method_call_result &= v.check_expr(index);
 420             }
 421             if let Some(def) = v.tables.type_dependent_defs().get(e.hir_id) {
 422                 let def_id = def.def_id();
 423                 match v.tcx.associated_item(def_id).container {
 424                     ty::ImplContainer(_) => method_call_result & v.handle_const_fn_call(def_id),
 425                     ty::TraitContainer(_) => NotPromotable,
 426                 }
 427             } else {
 428                 v.tcx.sess.delay_span_bug(e.span, "no type-dependent def for method call");
 429                 NotPromotable
 430             }
 431         }
 432         hir::ExprKind::Struct(ref _qpath, ref hirvec, ref option_expr) => {
 433             let mut struct_result = Promotable;
 434             for index in hirvec.iter() {
 435                 struct_result &= v.check_expr(&index.expr);
 436             }
 437             if let Some(ref expr) = *option_expr {
 438                 struct_result &= v.check_expr(&expr);
 439             }
 440             if let ty::Adt(adt, ..) = v.tables.expr_ty(e).sty {
 441                 // unsafe_cell_type doesn't necessarily exist with no_core
 442                 if Some(adt.did) == v.tcx.lang_items().unsafe_cell_type() {
 443                     return NotPromotable;
 444                 }
 445             }
 446             struct_result
 447         }
 448
 449         hir::ExprKind::Lit(_) |
 450         hir::ExprKind::Err => Promotable,
 451
 452         hir::ExprKind::AddrOf(_, ref expr) |
 453         hir::ExprKind::Repeat(ref expr, _) => {
 454             v.check_expr(&expr)
 455         }
 456
 457         hir::ExprKind::Closure(_capture_clause, ref _box_fn_decl,
 458                                body_id, _span, _option_generator_movability) => {
 459             let nested_body_promotable = v.check_nested_body(body_id);
 460             // Paths in constant contexts cannot refer to local variables,
 461             // as there are none, and thus closures can't have upvars there.
 462             if v.tcx.with_freevars(e.id, |fv| !fv.is_empty()) {
 463                 NotPromotable
 464             } else {
 465                 nested_body_promotable
 466             }
 467         }
 468
 469         hir::ExprKind::Field(ref expr, _ident) => {
 470             let expr_promotability = v.check_expr(&expr);
 471             if let Some(def) = v.tables.expr_ty(expr).ty_adt_def() {
 472                 if def.is_union() {
 473                     return NotPromotable;
 474                 }
 475             }
 476             expr_promotability
 477         }
 478
 479         hir::ExprKind::Block(ref box_block, ref _option_label) => {
 480             v.check_block(box_block)
 481         }
 482
 483         hir::ExprKind::Index(ref lhs, ref rhs) => {
 484             let lefty = v.check_expr(lhs);
 485             let righty = v.check_expr(rhs);
 486             if v.tables.is_method_call(e) {
 487                 return NotPromotable;
 488             }
 489             lefty & righty
 490         }
 491
 492         hir::ExprKind::Array(ref hirvec) => {
 493             let mut array_result = Promotable;
 494             for index in hirvec.iter() {
 495                 array_result &= v.check_expr(index);
 496             }
 497             array_result
 498         }
 499
 500         hir::ExprKind::Type(ref expr, ref _ty) => {
 501             v.check_expr(&expr)
 502         }
 503
 504         hir::ExprKind::Tup(ref hirvec) => {
 505             let mut tup_result = Promotable;
 506             for index in hirvec.iter() {
 507                 tup_result &= v.check_expr(index);
 508             }
 509             tup_result
 510         }
 511
 512
 513         // Conditional control flow (possible to implement).
 514         hir::ExprKind::Match(ref expr, ref hirvec_arm, ref _match_source) => {
 515             // Compute the most demanding borrow from all the arms'
 516             // patterns and set that on the discriminator.
 517             let mut mut_borrow = false;
 518             for pat in hirvec_arm.iter().flat_map(|arm| &arm.pats) {
 519                 mut_borrow = v.remove_mut_rvalue_borrow(pat);
 520             }
 521             if mut_borrow {
 522                 v.mut_rvalue_borrows.insert(expr.id);
 523             }
 524
 525             let _ = v.check_expr(expr);
 526             for index in hirvec_arm.iter() {
 527                 let _ = v.check_expr(&*index.body);
 528                 if let Some(hir::Guard::If(ref expr)) = index.guard {
 529                     let _ = v.check_expr(&expr);
 530                 }
 531             }
 532             NotPromotable
 533         }
 534
 535         hir::ExprKind::If(ref lhs, ref rhs, ref option_expr) => {
 536             let _ = v.check_expr(lhs);
 537             let _ = v.check_expr(rhs);
 538             if let Some(ref expr) = option_expr {
 539                 let _ = v.check_expr(&expr);
 540             }
 541             NotPromotable
 542         }
 543
 544         // Loops (not very meaningful in constants).
 545         hir::ExprKind::While(ref expr, ref box_block, ref _option_label) => {
 546             let _ = v.check_expr(expr);
 547             let _ = v.check_block(box_block);
 548             NotPromotable
 549         }
 550
 551         hir::ExprKind::Loop(ref box_block, ref _option_label, ref _loop_source) => {
 552             let _ = v.check_block(box_block);
 553             NotPromotable
 554         }
 555
 556         // More control flow (also not very meaningful).
 557         hir::ExprKind::Break(_, ref option_expr) | hir::ExprKind::Ret(ref option_expr) => {
 558             if let Some(ref expr) = *option_expr {
 559                  let _ = v.check_expr(&expr);
 560             }
 561             NotPromotable
 562         }
 563
 564         hir::ExprKind::Continue(_) => {
 565             NotPromotable
 566         }
 567
 568         // Generator expressions
 569         hir::ExprKind::Yield(ref expr) => {
 570             let _ = v.check_expr(&expr);
 571             NotPromotable
 572         }
 573
 574         // Expressions with side-effects.
 575         hir::ExprKind::AssignOp(_, ref lhs, ref rhs) | hir::ExprKind::Assign(ref lhs, ref rhs) => {
 576             let _ = v.check_expr(lhs);
 577             let _ = v.check_expr(rhs);
 578             NotPromotable
 579         }
 580
 581         hir::ExprKind::InlineAsm(ref _inline_asm, ref hirvec_lhs, ref hirvec_rhs) => {
 582             for index in hirvec_lhs.iter().chain(hirvec_rhs.iter()) {
 583                 let _ = v.check_expr(index);
 584             }
 585             NotPromotable
 586         }
 587     };
 588     ty_result & node_result
 589 }
 590
 591 /// Checks the adjustments of an expression.
 592 fn check_adjustments<'a, 'tcx>(
 593     v: &mut CheckCrateVisitor<'a, 'tcx>,
 594     e: &hir::Expr) -> Promotability {
 595     use rustc::ty::adjustment::*;
 596
 597     let mut adjustments = v.tables.expr_adjustments(e).iter().peekable();
 598     while let Some(adjustment) = adjustments.next() {
 599         match adjustment.kind {
 600             Adjust::NeverToAny |
 601             Adjust::ReifyFnPointer |
 602             Adjust::UnsafeFnPointer |
 603             Adjust::ClosureFnPointer |
 604             Adjust::MutToConstPointer |
 605             Adjust::Borrow(_) |
 606             Adjust::Unsize => {}
 607
 608             Adjust::Deref(_) => {
 609                 if let Some(next_adjustment) = adjustments.peek() {
 610                     if let Adjust::Borrow(_) = next_adjustment.kind {
 611                         continue;
 612                     }
 613                 }
 614                 return NotPromotable;
 615             }
 616         }
 617     }
 618     Promotable
 619 }
 620
 621 impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'gcx> {
 622     fn consume(&mut self,
 623                _consume_id: ast::NodeId,
 624                _consume_span: Span,
 625                _cmt: &mc::cmt_<'_>,
 626                _mode: euv::ConsumeMode) {}
 627
 628     fn borrow(&mut self,
 629               borrow_id: ast::NodeId,
 630               _borrow_span: Span,
 631               cmt: &mc::cmt_<'tcx>,
 632               _loan_region: ty::Region<'tcx>,
 633               bk: ty::BorrowKind,
 634               loan_cause: euv::LoanCause) {
 635         debug!(
 636             "borrow(borrow_id={:?}, cmt={:?}, bk={:?}, loan_cause={:?})",
 637             borrow_id,
 638             cmt,
 639             bk,
 640             loan_cause,
 641         );
 642
 643         // Kind of hacky, but we allow Unsafe coercions in constants.
 644         // These occur when we convert a &T or *T to a *U, as well as
 645         // when making a thin pointer (e.g., `*T`) into a fat pointer
 646         // (e.g., `*Trait`).
 647         if let euv::LoanCause::AutoUnsafe = loan_cause {
 648             return;
 649         }
 650
 651         let mut cur = cmt;
 652         loop {
 653             match cur.cat {
 654                 Categorization::ThreadLocal(..) |
 655                 Categorization::Rvalue(..) => {
 656                     if loan_cause == euv::MatchDiscriminant {
 657                         // Ignore the dummy immutable borrow created by EUV.
 658                         break;
 659                     }
 660                     if bk.to_mutbl_lossy() == hir::MutMutable {
 661                         self.mut_rvalue_borrows.insert(borrow_id);
 662                     }
 663                     break;
 664                 }
 665                 Categorization::StaticItem => {
 666                     break;
 667                 }
 668                 Categorization::Deref(ref cmt, _) |
 669                 Categorization::Downcast(ref cmt, _) |
 670                 Categorization::Interior(ref cmt, _) => {
 671                     cur = cmt;
 672                 }
 673
 674                 Categorization::Upvar(..) |
 675                 Categorization::Local(..) => break,
 676             }
 677         }
 678     }
 679
 680     fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) {}
 681     fn mutate(&mut self,
 682               _assignment_id: ast::NodeId,
 683               _assignment_span: Span,
 684               _assignee_cmt: &mc::cmt_<'_>,
 685               _mode: euv::MutateMode) {
 686     }
 687
 688     fn matched_pat(&mut self, _: &hir::Pat, _: &mc::cmt_<'_>, _: euv::MatchMode) {}
 689
 690     fn consume_pat(&mut self,
 691                    _consume_pat: &hir::Pat,
 692                    _cmt: &mc::cmt_<'_>,
 693                    _mode: euv::ConsumeMode) {}
 694 }