src/librustc_passes/rvalue_promotion.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // Verifies that the types and values of const and static items
  12 // are safe. The rules enforced by this module are:
  13 //
  14 // - For each *mutable* static item, it checks that its **type**:
  15 //     - doesn't have a destructor
  16 //     - doesn't own a box
  17 //
  18 // - For each *immutable* static item, it checks that its **value**:
  19 //       - doesn't own a box
  20 //       - doesn't contain a struct literal or a call to an enum variant / struct constructor where
  21 //           - the type of the struct/enum has a dtor
  22 //
  23 // Rules Enforced Elsewhere:
  24 // - It's not possible to take the address of a static item with unsafe interior. This is enforced
  25 // by borrowck::gather_loans
  26
  27 use rustc::ty::cast::CastKind;
  28 use rustc::hir::def::{Def, CtorKind};
  29 use rustc::hir::def_id::DefId;
  30 use rustc::hir::map::blocks::FnLikeNode;
  31 use rustc::middle::expr_use_visitor as euv;
  32 use rustc::middle::mem_categorization as mc;
  33 use rustc::middle::mem_categorization::Categorization;
  34 use rustc::ty::{self, Ty, TyCtxt};
  35 use rustc::ty::query::Providers;
  36 use rustc::ty::subst::Substs;
  37 use rustc::util::nodemap::{ItemLocalSet, NodeSet};
  38 use rustc::hir;
  39 use rustc_data_structures::sync::Lrc;
  40 use syntax::ast;
  41 use syntax::attr;
  42 use syntax_pos::{Span, DUMMY_SP};
  43 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
  44
  45 pub fn provide(providers: &mut Providers) {
  46     *providers = Providers {
  47         rvalue_promotable_map,
  48         const_is_rvalue_promotable_to_static,
  49         ..*providers
  50     };
  51 }
  52
  53 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
  54     for &body_id in &tcx.hir.krate().body_ids {
  55         let def_id = tcx.hir.body_owner_def_id(body_id);
  56         tcx.const_is_rvalue_promotable_to_static(def_id);
  57     }
  58     tcx.sess.abort_if_errors();
  59 }
  60
  61 fn const_is_rvalue_promotable_to_static<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
  62                                                   def_id: DefId)
  63                                                   -> bool
  64 {
  65     assert!(def_id.is_local());
  66
  67     let node_id = tcx.hir.as_local_node_id(def_id)
  68                      .expect("rvalue_promotable_map invoked with non-local def-id");
  69     let body_id = tcx.hir.body_owned_by(node_id);
  70     let body_hir_id = tcx.hir.node_to_hir_id(body_id.node_id);
  71     tcx.rvalue_promotable_map(def_id).contains(&body_hir_id.local_id)
  72 }
  73
  74 fn rvalue_promotable_map<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
  75                                    def_id: DefId)
  76                                    -> Lrc<ItemLocalSet>
  77 {
  78     let outer_def_id = tcx.closure_base_def_id(def_id);
  79     if outer_def_id != def_id {
  80         return tcx.rvalue_promotable_map(outer_def_id);
  81     }
  82
  83     let mut visitor = CheckCrateVisitor {
  84         tcx,
  85         tables: &ty::TypeckTables::empty(None),
  86         in_fn: false,
  87         in_static: false,
  88         promotable: false,
  89         mut_rvalue_borrows: NodeSet(),
  90         param_env: ty::ParamEnv::empty(),
  91         identity_substs: Substs::empty(),
  92         result: ItemLocalSet(),
  93     };
  94
  95     // `def_id` should be a `Body` owner
  96     let node_id = tcx.hir.as_local_node_id(def_id)
  97                      .expect("rvalue_promotable_map invoked with non-local def-id");
  98     let body_id = tcx.hir.body_owned_by(node_id);
  99     visitor.visit_nested_body(body_id);
 100
 101     Lrc::new(visitor.result)
 102 }
 103
 104 struct CheckCrateVisitor<'a, 'tcx: 'a> {
 105     tcx: TyCtxt<'a, 'tcx, 'tcx>,
 106     in_fn: bool,
 107     in_static: bool,
 108     promotable: bool,
 109     mut_rvalue_borrows: NodeSet,
 110     param_env: ty::ParamEnv<'tcx>,
 111     identity_substs: &'tcx Substs<'tcx>,
 112     tables: &'a ty::TypeckTables<'tcx>,
 113     result: ItemLocalSet,
 114 }
 115
 116 impl<'a, 'gcx> CheckCrateVisitor<'a, 'gcx> {
 117     // Returns true iff all the values of the type are promotable.
 118     fn type_has_only_promotable_values(&mut self, ty: Ty<'gcx>) -> bool {
 119         ty.is_freeze(self.tcx, self.param_env, DUMMY_SP) &&
 120         !ty.needs_drop(self.tcx, self.param_env)
 121     }
 122
 123     fn handle_const_fn_call(&mut self, def_id: DefId, ret_ty: Ty<'gcx>, span: Span) {
 124         self.promotable &= self.type_has_only_promotable_values(ret_ty);
 125
 126         self.promotable &= if let Some(fn_id) = self.tcx.hir.as_local_node_id(def_id) {
 127             FnLikeNode::from_node(self.tcx.hir.get(fn_id)).map_or(false, |fn_like| {
 128                 fn_like.constness() == hir::Constness::Const
 129             })
 130         } else {
 131             self.tcx.is_const_fn(def_id)
 132         };
 133
 134         if let Some(&attr::Stability {
 135             rustc_const_unstable: Some(attr::RustcConstUnstable {
 136                 feature: ref feature_name
 137             }),
 138         .. }) = self.tcx.lookup_stability(def_id) {
 139             self.promotable &=
 140                 // feature-gate is enabled,
 141                 self.tcx.features()
 142                     .declared_lib_features
 143                     .iter()
 144                     .any(|&(ref sym, _)| sym == feature_name) ||
 145
 146                 // this comes from a crate with the feature-gate enabled,
 147                 !def_id.is_local() ||
 148
 149                 // this comes from a macro that has #[allow_internal_unstable]
 150                 span.allows_unstable();
 151         }
 152     }
 153
 154     /// While the `ExprUseVisitor` walks, we will identify which
 155     /// expressions are borrowed, and insert their ids into this
 156     /// table. Actually, we insert the "borrow-id", which is normally
 157     /// the id of the expession being borrowed: but in the case of
 158     /// `ref mut` borrows, the `id` of the pattern is
 159     /// inserted. Therefore later we remove that entry from the table
 160     /// and transfer it over to the value being matched. This will
 161     /// then prevent said value from being promoted.
 162     fn remove_mut_rvalue_borrow(&mut self, pat: &hir::Pat) -> bool {
 163         let mut any_removed = false;
 164         pat.walk(|p| {
 165             any_removed |= self.mut_rvalue_borrows.remove(&p.id);
 166             true
 167         });
 168         any_removed
 169     }
 170 }
 171
 172 impl<'a, 'tcx> Visitor<'tcx> for CheckCrateVisitor<'a, 'tcx> {
 173     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
 174         // note that we *do* visit nested bodies, because we override `visit_nested_body` below
 175         NestedVisitorMap::None
 176     }
 177
 178     fn visit_nested_body(&mut self, body_id: hir::BodyId) {
 179         let item_id = self.tcx.hir.body_owner(body_id);
 180         let item_def_id = self.tcx.hir.local_def_id(item_id);
 181
 182         let outer_in_fn = self.in_fn;
 183         let outer_tables = self.tables;
 184         let outer_param_env = self.param_env;
 185         let outer_identity_substs = self.identity_substs;
 186
 187         self.in_fn = false;
 188         self.in_static = false;
 189
 190         match self.tcx.hir.body_owner_kind(item_id) {
 191             hir::BodyOwnerKind::Fn => self.in_fn = true,
 192             hir::BodyOwnerKind::Static(_) => self.in_static = true,
 193             _ => {}
 194         };
 195
 196
 197         self.tables = self.tcx.typeck_tables_of(item_def_id);
 198         self.param_env = self.tcx.param_env(item_def_id);
 199         self.identity_substs = Substs::identity_for_item(self.tcx, item_def_id);
 200
 201         let body = self.tcx.hir.body(body_id);
 202
 203         let tcx = self.tcx;
 204         let param_env = self.param_env;
 205         let region_scope_tree = self.tcx.region_scope_tree(item_def_id);
 206         euv::ExprUseVisitor::new(self, tcx, param_env, &region_scope_tree, self.tables, None)
 207             .consume_body(body);
 208
 209         self.visit_body(body);
 210
 211         self.in_fn = outer_in_fn;
 212         self.tables = outer_tables;
 213         self.param_env = outer_param_env;
 214         self.identity_substs = outer_identity_substs;
 215     }
 216
 217     fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt) {
 218         match stmt.node {
 219             hir::StmtDecl(ref decl, _) => {
 220                 match &decl.node {
 221                     hir::DeclLocal(local) => {
 222                         self.promotable = false;
 223
 224                         if self.remove_mut_rvalue_borrow(&local.pat) {
 225                             if let Some(init) = &local.init {
 226                                 self.mut_rvalue_borrows.insert(init.id);
 227                             }
 228                         }
 229                     }
 230                     // Item statements are allowed
 231                     hir::DeclItem(_) => {}
 232                 }
 233             }
 234             hir::StmtExpr(..) |
 235             hir::StmtSemi(..) => {
 236                 self.promotable = false;
 237             }
 238         }
 239         intravisit::walk_stmt(self, stmt);
 240     }
 241
 242     fn visit_expr(&mut self, ex: &'tcx hir::Expr) {
 243         let outer = self.promotable;
 244         self.promotable = true;
 245
 246         let node_ty = self.tables.node_id_to_type(ex.hir_id);
 247         check_expr(self, ex, node_ty);
 248         check_adjustments(self, ex);
 249
 250         if let hir::ExprMatch(ref discr, ref arms, _) = ex.node {
 251             // Compute the most demanding borrow from all the arms'
 252             // patterns and set that on the discriminator.
 253             let mut mut_borrow = false;
 254             for pat in arms.iter().flat_map(|arm| &arm.pats) {
 255                 mut_borrow = self.remove_mut_rvalue_borrow(pat);
 256             }
 257             if mut_borrow {
 258                 self.mut_rvalue_borrows.insert(discr.id);
 259             }
 260         }
 261
 262         intravisit::walk_expr(self, ex);
 263
 264         // Handle borrows on (or inside the autorefs of) this expression.
 265         if self.mut_rvalue_borrows.remove(&ex.id) {
 266             self.promotable = false;
 267         }
 268
 269         if self.promotable {
 270             self.result.insert(ex.hir_id.local_id);
 271         }
 272         self.promotable &= outer;
 273     }
 274 }
 275
 276 /// This function is used to enforce the constraints on
 277 /// const/static items. It walks through the *value*
 278 /// of the item walking down the expression and evaluating
 279 /// every nested expression. If the expression is not part
 280 /// of a const/static item, it is qualified for promotion
 281 /// instead of producing errors.
 282 fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr, node_ty: Ty<'tcx>) {
 283     match node_ty.sty {
 284         ty::TyAdt(def, _) if def.has_dtor(v.tcx) => {
 285             v.promotable = false;
 286         }
 287         _ => {}
 288     }
 289
 290     match e.node {
 291         hir::ExprUnary(..) |
 292         hir::ExprBinary(..) |
 293         hir::ExprIndex(..) if v.tables.is_method_call(e) => {
 294             v.promotable = false;
 295         }
 296         hir::ExprBox(_) => {
 297             v.promotable = false;
 298         }
 299         hir::ExprUnary(op, _) => {
 300             if op == hir::UnDeref {
 301                 v.promotable = false;
 302             }
 303         }
 304         hir::ExprBinary(op, ref lhs, _) => {
 305             match v.tables.node_id_to_type(lhs.hir_id).sty {
 306                 ty::TyRawPtr(_) => {
 307                     assert!(op.node == hir::BiEq || op.node == hir::BiNe ||
 308                             op.node == hir::BiLe || op.node == hir::BiLt ||
 309                             op.node == hir::BiGe || op.node == hir::BiGt);
 310
 311                     v.promotable = false;
 312                 }
 313                 _ => {}
 314             }
 315         }
 316         hir::ExprCast(ref from, _) => {
 317             debug!("Checking const cast(id={})", from.id);
 318             match v.tables.cast_kinds().get(from.hir_id) {
 319                 None => v.tcx.sess.delay_span_bug(e.span, "no kind for cast"),
 320                 Some(&CastKind::PtrAddrCast) | Some(&CastKind::FnPtrAddrCast) => {
 321                     v.promotable = false;
 322                 }
 323                 _ => {}
 324             }
 325         }
 326         hir::ExprPath(ref qpath) => {
 327             let def = v.tables.qpath_def(qpath, e.hir_id);
 328             match def {
 329                 Def::VariantCtor(..) | Def::StructCtor(..) |
 330                 Def::Fn(..) | Def::Method(..) =>  {}
 331
 332                 // References to a static that are themselves within a static
 333                 // are inherently promotable with the exception
 334                 //  of "#[thread_local]" statics, which may not
 335                 // outlive the current function
 336                 Def::Static(did, _) => {
 337
 338                     if v.in_static {
 339                         let mut thread_local = false;
 340
 341                         for attr in &v.tcx.get_attrs(did)[..] {
 342                             if attr.check_name("thread_local") {
 343                                 debug!("Reference to Static(id={:?}) is unpromotable \
 344                                        due to a #[thread_local] attribute", did);
 345                                 v.promotable = false;
 346                                 thread_local = true;
 347                                 break;
 348                             }
 349                         }
 350
 351                         if !thread_local {
 352                             debug!("Allowing promotion of reference to Static(id={:?})", did);
 353                         }
 354                     } else {
 355                         debug!("Reference to Static(id={:?}) is unpromotable as it is not \
 356                                referenced from a static", did);
 357                         v.promotable = false;
 358
 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                         false
 367                     } else {
 368                         v.tcx.at(e.span).const_is_rvalue_promotable_to_static(did)
 369                     };
 370
 371                     // Just in case the type is more specific than the definition,
 372                     // e.g. impl associated const with type parameters, check it.
 373                     // Also, trait associated consts are relaxed by this.
 374                     v.promotable &= promotable || v.type_has_only_promotable_values(node_ty);
 375                 }
 376
 377                 _ => {
 378                     v.promotable = false;
 379                 }
 380             }
 381         }
 382         hir::ExprCall(ref callee, _) => {
 383             let mut callee = &**callee;
 384             loop {
 385                 callee = match callee.node {
 386                     hir::ExprBlock(ref block, _) => match block.expr {
 387                         Some(ref tail) => &tail,
 388                         None => break
 389                     },
 390                     _ => break
 391                 };
 392             }
 393             // The callee is an arbitrary expression, it doesn't necessarily have a definition.
 394             let def = if let hir::ExprPath(ref qpath) = callee.node {
 395                 v.tables.qpath_def(qpath, callee.hir_id)
 396             } else {
 397                 Def::Err
 398             };
 399             match def {
 400                 Def::StructCtor(_, CtorKind::Fn) |
 401                 Def::VariantCtor(_, CtorKind::Fn) => {}
 402                 Def::Fn(did) => {
 403                     v.handle_const_fn_call(did, node_ty, e.span)
 404                 }
 405                 Def::Method(did) => {
 406                     match v.tcx.associated_item(did).container {
 407                         ty::ImplContainer(_) => {
 408                             v.handle_const_fn_call(did, node_ty, e.span)
 409                         }
 410                         ty::TraitContainer(_) => v.promotable = false
 411                     }
 412                 }
 413                 _ => v.promotable = false
 414             }
 415         }
 416         hir::ExprMethodCall(..) => {
 417             if let Some(def) = v.tables.type_dependent_defs().get(e.hir_id) {
 418                 let def_id = def.def_id();
 419                 match v.tcx.associated_item(def_id).container {
 420                     ty::ImplContainer(_) => v.handle_const_fn_call(def_id, node_ty, e.span),
 421                     ty::TraitContainer(_) => v.promotable = false
 422                 }
 423             } else {
 424                 v.tcx.sess.delay_span_bug(e.span, "no type-dependent def for method call");
 425             }
 426         }
 427         hir::ExprStruct(..) => {
 428             if let ty::TyAdt(adt, ..) = v.tables.expr_ty(e).sty {
 429                 // unsafe_cell_type doesn't necessarily exist with no_core
 430                 if Some(adt.did) == v.tcx.lang_items().unsafe_cell_type() {
 431                     v.promotable = false;
 432                 }
 433             }
 434         }
 435
 436         hir::ExprLit(_) |
 437         hir::ExprAddrOf(..) |
 438         hir::ExprRepeat(..) => {}
 439
 440         hir::ExprClosure(..) => {
 441             // Paths in constant contexts cannot refer to local variables,
 442             // as there are none, and thus closures can't have upvars there.
 443             if v.tcx.with_freevars(e.id, |fv| !fv.is_empty()) {
 444                 v.promotable = false;
 445             }
 446         }
 447
 448         hir::ExprField(ref expr, _) => {
 449             if let Some(def) = v.tables.expr_ty(expr).ty_adt_def() {
 450                 if def.is_union() {
 451                     v.promotable = false
 452                 }
 453             }
 454         }
 455
 456         hir::ExprBlock(..) |
 457         hir::ExprIndex(..) |
 458         hir::ExprArray(_) |
 459         hir::ExprType(..) |
 460         hir::ExprTup(..) => {}
 461
 462         // Conditional control flow (possible to implement).
 463         hir::ExprMatch(..) |
 464         hir::ExprIf(..) |
 465
 466         // Loops (not very meaningful in constants).
 467         hir::ExprWhile(..) |
 468         hir::ExprLoop(..) |
 469
 470         // More control flow (also not very meaningful).
 471         hir::ExprBreak(..) |
 472         hir::ExprAgain(_) |
 473         hir::ExprRet(_) |
 474
 475         // Generator expressions
 476         hir::ExprYield(_) |
 477
 478         // Expressions with side-effects.
 479         hir::ExprAssign(..) |
 480         hir::ExprAssignOp(..) |
 481         hir::ExprInlineAsm(..) => {
 482             v.promotable = false;
 483         }
 484     }
 485 }
 486
 487 /// Check the adjustments of an expression
 488 fn check_adjustments<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr) {
 489     use rustc::ty::adjustment::*;
 490
 491     let mut adjustments = v.tables.expr_adjustments(e).iter().peekable();
 492     while let Some(adjustment) = adjustments.next() {
 493         match adjustment.kind {
 494             Adjust::NeverToAny |
 495             Adjust::ReifyFnPointer |
 496             Adjust::UnsafeFnPointer |
 497             Adjust::ClosureFnPointer |
 498             Adjust::MutToConstPointer |
 499             Adjust::Borrow(_) |
 500             Adjust::Unsize => {}
 501
 502             Adjust::Deref(_) => {
 503                 if let Some(next_adjustment) = adjustments.peek() {
 504                     if let Adjust::Borrow(_) = next_adjustment.kind {
 505                         continue;
 506                     }
 507                 }
 508                 v.promotable = false;
 509                 break;
 510             }
 511         }
 512     }
 513 }
 514
 515 impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'gcx> {
 516     fn consume(&mut self,
 517                _consume_id: ast::NodeId,
 518                _consume_span: Span,
 519                _cmt: &mc::cmt_,
 520                _mode: euv::ConsumeMode) {}
 521
 522     fn borrow(&mut self,
 523               borrow_id: ast::NodeId,
 524               _borrow_span: Span,
 525               cmt: &mc::cmt_<'tcx>,
 526               _loan_region: ty::Region<'tcx>,
 527               bk: ty::BorrowKind,
 528               loan_cause: euv::LoanCause) {
 529         debug!(
 530             "borrow(borrow_id={:?}, cmt={:?}, bk={:?}, loan_cause={:?})",
 531             borrow_id,
 532             cmt,
 533             bk,
 534             loan_cause,
 535         );
 536
 537         // Kind of hacky, but we allow Unsafe coercions in constants.
 538         // These occur when we convert a &T or *T to a *U, as well as
 539         // when making a thin pointer (e.g., `*T`) into a fat pointer
 540         // (e.g., `*Trait`).
 541         match loan_cause {
 542             euv::LoanCause::AutoUnsafe => {
 543                 return;
 544             }
 545             _ => {}
 546         }
 547
 548         let mut cur = cmt;
 549         loop {
 550             match cur.cat {
 551                 Categorization::Rvalue(..) => {
 552                     if loan_cause == euv::MatchDiscriminant {
 553                         // Ignore the dummy immutable borrow created by EUV.
 554                         break;
 555                     }
 556                     if bk.to_mutbl_lossy() == hir::MutMutable {
 557                         self.mut_rvalue_borrows.insert(borrow_id);
 558                     }
 559                     break;
 560                 }
 561                 Categorization::StaticItem => {
 562                     break;
 563                 }
 564                 Categorization::Deref(ref cmt, _) |
 565                 Categorization::Downcast(ref cmt, _) |
 566                 Categorization::Interior(ref cmt, _) => {
 567                     cur = cmt;
 568                 }
 569
 570                 Categorization::Upvar(..) |
 571                 Categorization::Local(..) => break,
 572             }
 573         }
 574     }
 575
 576     fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) {}
 577     fn mutate(&mut self,
 578               _assignment_id: ast::NodeId,
 579               _assignment_span: Span,
 580               _assignee_cmt: &mc::cmt_,
 581               _mode: euv::MutateMode) {
 582     }
 583
 584     fn matched_pat(&mut self, _: &hir::Pat, _: &mc::cmt_, _: euv::MatchMode) {}
 585
 586     fn consume_pat(&mut self, _consume_pat: &hir::Pat, _cmt: &mc::cmt_, _mode: euv::ConsumeMode) {}
 587 }