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.
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.
11 // Verifies that the types and values of const and static items
12 // are safe. The rules enforced by this module are:
14 // - For each *mutable* static item, it checks that its **type**:
15 // - doesn't have a destructor
16 // - doesn't own a box
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
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
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};
39 use rustc_data_structures::sync::Lrc;
42 use syntax_pos::{Span, DUMMY_SP};
43 use self::Promotability::*;
44 use std::ops::{BitAnd, BitOr};
47 pub fn provide(providers: &mut Providers) {
48 *providers = Providers {
49 rvalue_promotable_map,
50 const_is_rvalue_promotable_to_static,
55 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
56 for &body_id in &tcx.hir.krate().body_ids {
57 let def_id = tcx.hir.body_owner_def_id(body_id);
58 tcx.const_is_rvalue_promotable_to_static(def_id);
60 tcx.sess.abort_if_errors();
63 fn const_is_rvalue_promotable_to_static<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
67 assert!(def_id.is_local());
69 let node_id = tcx.hir.as_local_node_id(def_id)
70 .expect("rvalue_promotable_map invoked with non-local def-id");
71 let body_id = tcx.hir.body_owned_by(node_id);
72 let body_hir_id = tcx.hir.node_to_hir_id(body_id.node_id);
73 tcx.rvalue_promotable_map(def_id).contains(&body_hir_id.local_id)
76 fn rvalue_promotable_map<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
80 let outer_def_id = tcx.closure_base_def_id(def_id);
81 if outer_def_id != def_id {
82 return tcx.rvalue_promotable_map(outer_def_id);
85 let mut visitor = CheckCrateVisitor {
87 tables: &ty::TypeckTables::empty(None),
90 mut_rvalue_borrows: NodeSet(),
91 param_env: ty::ParamEnv::empty(),
92 identity_substs: Substs::empty(),
93 result: ItemLocalSet(),
96 // `def_id` should be a `Body` owner
97 let node_id = tcx.hir.as_local_node_id(def_id)
98 .expect("rvalue_promotable_map invoked with non-local def-id");
99 let body_id = tcx.hir.body_owned_by(node_id);
100 let _ = visitor.check_nested_body(body_id);
102 Lrc::new(visitor.result)
105 struct CheckCrateVisitor<'a, 'tcx: 'a> {
106 tcx: TyCtxt<'a, 'tcx, 'tcx>,
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,
117 #[derive(Debug, PartialEq)]
123 impl BitAnd for Promotability {
126 fn bitand(self, rhs: Self) -> Self {
128 (Promotable, NotPromotable) => NotPromotable,
129 (NotPromotable, Promotable) => NotPromotable,
130 (NotPromotable, NotPromotable) => NotPromotable,
131 (Promotable, Promotable) => Promotable,
136 impl BitOr for Promotability {
139 fn bitor(self, rhs: Self) -> Self {
141 (Promotable, NotPromotable) => Promotable,
142 (NotPromotable, Promotable) => Promotable,
143 (NotPromotable, NotPromotable) => NotPromotable,
144 (Promotable, Promotable) => Promotable,
149 impl<'a, 'gcx> CheckCrateVisitor<'a, 'gcx> {
150 // Returns true iff all the values of the type are promotable.
151 fn type_promotability(&mut self, ty: Ty<'gcx>) -> Promotability {
152 debug!("type_promotability({})", ty);
154 if ty.is_freeze(self.tcx, self.param_env, DUMMY_SP) &&
155 !ty.needs_drop(self.tcx, self.param_env) {
162 fn handle_const_fn_call(&mut self, def_id: DefId,
163 ret_ty: Ty<'gcx>, span: Span) -> Promotability {
164 if let NotPromotable = self.type_promotability(ret_ty) {
165 return NotPromotable;
168 let node_check = if let Some(fn_id) = self.tcx.hir.as_local_node_id(def_id) {
169 FnLikeNode::from_node(self.tcx.hir.get(fn_id)).map_or(false, |fn_like| {
170 fn_like.constness() == hir::Constness::Const
173 self.tcx.is_const_fn(def_id)
180 if let Some(&attr::Stability {
181 rustc_const_unstable: Some(attr::RustcConstUnstable {
182 feature: ref feature_name
184 .. }) = self.tcx.lookup_stability(def_id) {
186 // feature-gate is enabled,
188 .declared_lib_features
190 .any(|&(ref sym, _)| sym == feature_name) ||
192 // this comes from a crate with the feature-gate enabled,
193 !def_id.is_local() ||
195 // this comes from a macro that has #[allow_internal_unstable]
196 span.allows_unstable();
204 /// While the `ExprUseVisitor` walks, we will identify which
205 /// expressions are borrowed, and insert their ids into this
206 /// table. Actually, we insert the "borrow-id", which is normally
207 /// the id of the expession being borrowed: but in the case of
208 /// `ref mut` borrows, the `id` of the pattern is
209 /// inserted. Therefore later we remove that entry from the table
210 /// and transfer it over to the value being matched. This will
211 /// then prevent said value from being promoted.
212 fn remove_mut_rvalue_borrow(&mut self, pat: &hir::Pat) -> bool {
213 let mut any_removed = false;
215 any_removed |= self.mut_rvalue_borrows.remove(&p.id);
222 impl<'a, 'tcx> CheckCrateVisitor<'a, 'tcx> {
223 fn check_nested_body(&mut self, body_id: hir::BodyId) -> Promotability {
224 let item_id = self.tcx.hir.body_owner(body_id);
225 let item_def_id = self.tcx.hir.local_def_id(item_id);
227 let outer_in_fn = self.in_fn;
228 let outer_tables = self.tables;
229 let outer_param_env = self.param_env;
230 let outer_identity_substs = self.identity_substs;
233 self.in_static = false;
235 match self.tcx.hir.body_owner_kind(item_id) {
236 hir::BodyOwnerKind::Fn => self.in_fn = true,
237 hir::BodyOwnerKind::Static(_) => self.in_static = true,
242 self.tables = self.tcx.typeck_tables_of(item_def_id);
243 self.param_env = self.tcx.param_env(item_def_id);
244 self.identity_substs = Substs::identity_for_item(self.tcx, item_def_id);
246 let body = self.tcx.hir.body(body_id);
249 let param_env = self.param_env;
250 let region_scope_tree = self.tcx.region_scope_tree(item_def_id);
251 let tables = self.tables;
252 euv::ExprUseVisitor::new(self, tcx, param_env, ®ion_scope_tree, tables, None)
255 let body_promotable = self.check_expr(&body.value);
256 self.in_fn = outer_in_fn;
257 self.tables = outer_tables;
258 self.param_env = outer_param_env;
259 self.identity_substs = outer_identity_substs;
263 fn check_stmt(&mut self, stmt: &'tcx hir::Stmt) -> Promotability {
265 hir::StmtKind::Decl(ref decl, _node_id) => {
267 hir::DeclKind::Local(local) => {
268 if self.remove_mut_rvalue_borrow(&local.pat) {
269 if let Some(init) = &local.init {
270 self.mut_rvalue_borrows.insert(init.id);
275 Some(ref expr) => { let _ = self.check_expr(&expr); },
280 // Item statements are allowed
281 hir::DeclKind::Item(_) => Promotable
284 hir::StmtKind::Expr(ref box_expr, _node_id) |
285 hir::StmtKind::Semi(ref box_expr, _node_id) => {
286 let _ = self.check_expr(box_expr);
292 fn check_expr(&mut self, ex: &'tcx hir::Expr) -> Promotability {
293 let node_ty = self.tables.node_id_to_type(ex.hir_id);
294 let mut outer = check_expr_kind(self, ex, node_ty);
295 outer = outer & check_adjustments(self, ex);
297 // Handle borrows on (or inside the autorefs of) this expression.
298 if self.mut_rvalue_borrows.remove(&ex.id) {
299 outer = NotPromotable
302 if outer == Promotable {
303 self.result.insert(ex.hir_id.local_id);
308 fn check_block(&mut self, block: &'tcx hir::Block) -> Promotability {
309 let mut iter_result = Promotable;
310 for index in block.stmts.iter() {
311 iter_result = iter_result & self.check_stmt(index);
314 Some(ref box_expr) => iter_result & self.check_expr(&*box_expr),
320 /// This function is used to enforce the constraints on
321 /// const/static items. It walks through the *value*
322 /// of the item walking down the expression and evaluating
323 /// every nested expression. If the expression is not part
324 /// of a const/static item, it is qualified for promotion
325 /// instead of producing errors.
326 fn check_expr_kind<'a, 'tcx>(
327 v: &mut CheckCrateVisitor<'a, 'tcx>,
328 e: &'tcx hir::Expr, node_ty: Ty<'tcx>) -> Promotability {
330 let ty_result = match node_ty.sty {
331 ty::Adt(def, _) if def.has_dtor(v.tcx) => {
337 let node_result = match e.node {
338 hir::ExprKind::Box(ref expr) => {
339 let _ = v.check_expr(&expr);
342 hir::ExprKind::Unary(op, ref expr) => {
343 let expr_promotability = v.check_expr(expr);
344 if v.tables.is_method_call(e) {
345 return NotPromotable;
347 if op == hir::UnDeref {
348 return NotPromotable;
352 hir::ExprKind::Binary(op, ref lhs, ref rhs) => {
353 let lefty = v.check_expr(lhs);
354 let righty = v.check_expr(rhs);
355 if v.tables.is_method_call(e) {
356 return NotPromotable;
358 match v.tables.node_id_to_type(lhs.hir_id).sty {
360 assert!(op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne ||
361 op.node == hir::BinOpKind::Le || op.node == hir::BinOpKind::Lt ||
362 op.node == hir::BinOpKind::Ge || op.node == hir::BinOpKind::Gt);
369 hir::ExprKind::Cast(ref from, _) => {
370 let expr_promotability = v.check_expr(from);
371 debug!("Checking const cast(id={})", from.id);
372 match v.tables.cast_kinds().get(from.hir_id) {
374 v.tcx.sess.delay_span_bug(e.span, "no kind for cast");
377 Some(&CastKind::PtrAddrCast) | Some(&CastKind::FnPtrAddrCast) => {
380 _ => expr_promotability
383 hir::ExprKind::Path(ref qpath) => {
384 let def = v.tables.qpath_def(qpath, e.hir_id);
386 Def::VariantCtor(..) | Def::StructCtor(..) |
387 Def::Fn(..) | Def::Method(..) => Promotable,
389 // References to a static that are themselves within a static
390 // are inherently promotable with the exception
391 // of "#[thread_local]" statics, which may not
392 // outlive the current function
393 Def::Static(did, _) => {
396 for attr in &v.tcx.get_attrs(did)[..] {
397 if attr.check_name("thread_local") {
398 debug!("Reference to Static(id={:?}) is unpromotable \
399 due to a #[thread_local] attribute", did);
400 return NotPromotable;
405 debug!("Reference to Static(id={:?}) is unpromotable as it is not \
406 referenced from a static", did);
413 Def::AssociatedConst(did) => {
414 let promotable = if v.tcx.trait_of_item(did).is_some() {
415 // Don't peek inside trait associated constants.
417 } else if v.tcx.at(e.span).const_is_rvalue_promotable_to_static(did) {
422 // Just in case the type is more specific than the definition,
423 // e.g. impl associated const with type parameters, check it.
424 // Also, trait associated consts are relaxed by this.
425 promotable | v.type_promotability(node_ty)
430 hir::ExprKind::Call(ref callee, ref hirvec) => {
431 let mut call_result = v.check_expr(callee);
432 for index in hirvec.iter() {
433 call_result = call_result & v.check_expr(index);
435 let mut callee = &**callee;
437 callee = match callee.node {
438 hir::ExprKind::Block(ref block, _) => match block.expr {
439 Some(ref tail) => &tail,
445 // The callee is an arbitrary expression, it doesn't necessarily have a definition.
446 let def = if let hir::ExprKind::Path(ref qpath) = callee.node {
447 v.tables.qpath_def(qpath, callee.hir_id)
451 let def_result = match def {
452 Def::StructCtor(_, CtorKind::Fn) |
453 Def::VariantCtor(_, CtorKind::Fn) => Promotable,
455 v.handle_const_fn_call(did, node_ty, e.span)
457 Def::Method(did) => {
458 match v.tcx.associated_item(did).container {
459 ty::ImplContainer(_) => {
460 v.handle_const_fn_call(did, node_ty, e.span)
462 ty::TraitContainer(_) => NotPromotable,
467 def_result & call_result
469 hir::ExprKind::MethodCall(ref _pathsegment, ref _span, ref hirvec) => {
470 let mut method_call_result = Promotable;
471 for index in hirvec.iter() {
472 method_call_result = method_call_result & v.check_expr(index);
474 if let Some(def) = v.tables.type_dependent_defs().get(e.hir_id) {
475 let def_id = def.def_id();
476 match v.tcx.associated_item(def_id).container {
477 ty::ImplContainer(_) => {
478 method_call_result = method_call_result
479 & v.handle_const_fn_call(def_id, node_ty, e.span);
481 ty::TraitContainer(_) => return NotPromotable,
484 v.tcx.sess.delay_span_bug(e.span, "no type-dependent def for method call");
488 hir::ExprKind::Struct(ref _qpath, ref hirvec, ref option_expr) => {
489 let mut struct_result = Promotable;
490 for index in hirvec.iter() {
491 struct_result = struct_result & v.check_expr(&index.expr);
494 Some(ref expr) => { struct_result = struct_result & v.check_expr(&expr); },
497 if let ty::Adt(adt, ..) = v.tables.expr_ty(e).sty {
498 // unsafe_cell_type doesn't necessarily exist with no_core
499 if Some(adt.did) == v.tcx.lang_items().unsafe_cell_type() {
500 return NotPromotable;
506 hir::ExprKind::Lit(_) => Promotable,
508 hir::ExprKind::AddrOf(_, ref expr) |
509 hir::ExprKind::Repeat(ref expr, _) => {
513 hir::ExprKind::Closure(_capture_clause, ref _box_fn_decl,
514 body_id, _span, _option_generator_movability) => {
515 let nested_body_promotable = v.check_nested_body(body_id);
516 // Paths in constant contexts cannot refer to local variables,
517 // as there are none, and thus closures can't have upvars there.
518 if v.tcx.with_freevars(e.id, |fv| !fv.is_empty()) {
521 nested_body_promotable
525 hir::ExprKind::Field(ref expr, _ident) => {
526 let expr_promotability = v.check_expr(&expr);
527 if let Some(def) = v.tables.expr_ty(expr).ty_adt_def() {
529 return NotPromotable;
535 hir::ExprKind::Block(ref box_block, ref _option_label) => {
536 v.check_block(box_block)
539 hir::ExprKind::Index(ref lhs, ref rhs) => {
540 let lefty = v.check_expr(lhs);
541 let righty = v.check_expr(rhs);
542 if v.tables.is_method_call(e) {
543 return NotPromotable;
548 hir::ExprKind::Array(ref hirvec) => {
549 let mut array_result = Promotable;
550 for index in hirvec.iter() {
551 array_result = array_result & v.check_expr(index);
556 hir::ExprKind::Type(ref expr, ref _ty) => {
560 hir::ExprKind::Tup(ref hirvec) => {
561 let mut tup_result = Promotable;
562 for index in hirvec.iter() {
563 tup_result = tup_result & v.check_expr(index);
569 // Conditional control flow (possible to implement).
570 hir::ExprKind::Match(ref expr, ref hirvec_arm, ref _match_source) => {
571 // Compute the most demanding borrow from all the arms'
572 // patterns and set that on the discriminator.
573 let mut mut_borrow = false;
574 for pat in hirvec_arm.iter().flat_map(|arm| &arm.pats) {
575 mut_borrow = v.remove_mut_rvalue_borrow(pat);
578 v.mut_rvalue_borrows.insert(expr.id);
581 let _ = v.check_expr(expr);
582 for index in hirvec_arm.iter() {
583 let _ = v.check_expr(&*index.body);
586 let _ = v.check_expr(&expr);
594 hir::ExprKind::If(ref lhs, ref rhs, ref option_expr) => {
595 let _ = v.check_expr(lhs);
596 let _ = v.check_expr(rhs);
598 Some(ref expr) => { let _ = v.check_expr(&expr); },
604 // Loops (not very meaningful in constants).
605 hir::ExprKind::While(ref expr, ref box_block, ref _option_label) => {
606 let _ = v.check_expr(expr);
607 let _ = v.check_block(box_block);
611 hir::ExprKind::Loop(ref box_block, ref _option_label, ref _loop_source) => {
612 let _ = v.check_block(box_block);
616 // More control flow (also not very meaningful).
617 hir::ExprKind::Break(_, ref option_expr) | hir::ExprKind::Ret(ref option_expr) => {
619 Some(ref expr) => { let _ = v.check_expr(&expr); },
625 hir::ExprKind::Continue(_) => {
629 // Generator expressions
630 hir::ExprKind::Yield(ref expr) => {
631 let _ = v.check_expr(&expr);
635 // Expressions with side-effects.
636 hir::ExprKind::AssignOp(_, ref lhs, ref rhs) | hir::ExprKind::Assign(ref lhs, ref rhs) => {
637 let _ = v.check_expr(lhs);
638 let _ = v.check_expr(rhs);
642 hir::ExprKind::InlineAsm(ref _inline_asm, ref hirvec_lhs, ref hirvec_rhs) => {
643 for index in hirvec_lhs.iter() {
644 let _ = v.check_expr(index);
646 for index in hirvec_rhs.iter() {
647 let _ = v.check_expr(index);
652 ty_result & node_result
655 /// Check the adjustments of an expression
656 fn check_adjustments<'a, 'tcx>(
657 v: &mut CheckCrateVisitor<'a, 'tcx>,
658 e: &hir::Expr) -> Promotability {
659 use rustc::ty::adjustment::*;
661 let mut adjustments = v.tables.expr_adjustments(e).iter().peekable();
662 while let Some(adjustment) = adjustments.next() {
663 match adjustment.kind {
665 Adjust::ReifyFnPointer |
666 Adjust::UnsafeFnPointer |
667 Adjust::ClosureFnPointer |
668 Adjust::MutToConstPointer |
672 Adjust::Deref(_) => {
673 if let Some(next_adjustment) = adjustments.peek() {
674 if let Adjust::Borrow(_) = next_adjustment.kind {
678 return NotPromotable;
685 impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'gcx> {
686 fn consume(&mut self,
687 _consume_id: ast::NodeId,
690 _mode: euv::ConsumeMode) {}
693 borrow_id: ast::NodeId,
695 cmt: &mc::cmt_<'tcx>,
696 _loan_region: ty::Region<'tcx>,
698 loan_cause: euv::LoanCause) {
700 "borrow(borrow_id={:?}, cmt={:?}, bk={:?}, loan_cause={:?})",
707 // Kind of hacky, but we allow Unsafe coercions in constants.
708 // These occur when we convert a &T or *T to a *U, as well as
709 // when making a thin pointer (e.g., `*T`) into a fat pointer
712 euv::LoanCause::AutoUnsafe => {
721 Categorization::Rvalue(..) => {
722 if loan_cause == euv::MatchDiscriminant {
723 // Ignore the dummy immutable borrow created by EUV.
726 if bk.to_mutbl_lossy() == hir::MutMutable {
727 self.mut_rvalue_borrows.insert(borrow_id);
731 Categorization::StaticItem => {
734 Categorization::Deref(ref cmt, _) |
735 Categorization::Downcast(ref cmt, _) |
736 Categorization::Interior(ref cmt, _) => {
740 Categorization::Upvar(..) |
741 Categorization::Local(..) => break,
746 fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) {}
748 _assignment_id: ast::NodeId,
749 _assignment_span: Span,
750 _assignee_cmt: &mc::cmt_,
751 _mode: euv::MutateMode) {
754 fn matched_pat(&mut self, _: &hir::Pat, _: &mc::cmt_, _: euv::MatchMode) {}
756 fn consume_pat(&mut self, _consume_pat: &hir::Pat, _cmt: &mc::cmt_, _mode: euv::ConsumeMode) {}