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_const_eval::ConstContext;
29 use rustc::middle::const_val::ConstEvalErr;
30 use rustc::middle::const_val::ErrKind::{IndexOpFeatureGated, UnimplementedConstVal, MiscCatchAll};
31 use rustc::middle::const_val::ErrKind::{ErroneousReferencedConstant, MiscBinaryOp, NonConstPath};
32 use rustc::middle::const_val::ErrKind::{TypeckError, Math};
33 use rustc_const_math::{ConstMathErr, Op};
34 use rustc::hir::def::{Def, CtorKind};
35 use rustc::hir::def_id::DefId;
36 use rustc::hir::map::blocks::FnLikeNode;
37 use rustc::middle::expr_use_visitor as euv;
38 use rustc::middle::mem_categorization as mc;
39 use rustc::middle::mem_categorization::Categorization;
40 use rustc::mir::transform::MirSource;
41 use rustc::ty::{self, Ty, TyCtxt};
42 use rustc::traits::Reveal;
43 use rustc::util::common::ErrorReported;
44 use rustc::util::nodemap::NodeSet;
45 use rustc::lint::builtin::CONST_ERR;
47 use rustc::hir::{self, PatKind, RangeEnd};
49 use syntax_pos::{Span, DUMMY_SP};
50 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
52 use std::collections::hash_map::Entry;
53 use std::cmp::Ordering;
56 struct CheckCrateVisitor<'a, 'tcx: 'a> {
57 tcx: TyCtxt<'a, 'tcx, 'tcx>,
60 mut_rvalue_borrows: NodeSet,
61 param_env: ty::ParamEnv<'tcx>,
62 tables: &'a ty::TypeckTables<'tcx>,
65 impl<'a, 'gcx> CheckCrateVisitor<'a, 'gcx> {
66 fn check_const_eval(&self, expr: &'gcx hir::Expr) {
67 let const_cx = ConstContext::with_tables(self.tcx, self.tables);
68 if let Err(err) = const_cx.eval(expr) {
70 UnimplementedConstVal(_) => {}
71 IndexOpFeatureGated => {}
72 ErroneousReferencedConstant(_) => {}
75 self.tcx.sess.add_lint(CONST_ERR,
78 format!("constant evaluation error: {}. This will \
79 become a HARD ERROR in the future",
80 err.description().into_oneline()))
86 // Adds the worst effect out of all the values of one type.
87 fn add_type(&mut self, ty: Ty<'gcx>) {
88 if !ty.is_freeze(self.tcx, self.param_env, DUMMY_SP) {
89 self.promotable = false;
92 if ty.needs_drop(self.tcx, self.param_env) {
93 self.promotable = false;
97 fn handle_const_fn_call(&mut self, def_id: DefId, ret_ty: Ty<'gcx>) {
98 self.add_type(ret_ty);
100 self.promotable &= if let Some(fn_id) = self.tcx.hir.as_local_node_id(def_id) {
101 FnLikeNode::from_node(self.tcx.hir.get(fn_id)).map_or(false, |fn_like| {
102 fn_like.constness() == hir::Constness::Const
105 self.tcx.sess.cstore.is_const_fn(def_id)
110 impl<'a, 'tcx> Visitor<'tcx> for CheckCrateVisitor<'a, 'tcx> {
111 fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
112 NestedVisitorMap::None
115 fn visit_nested_body(&mut self, body_id: hir::BodyId) {
116 match self.tcx.rvalue_promotable_to_static.borrow_mut().entry(body_id.node_id) {
117 Entry::Occupied(_) => return,
118 Entry::Vacant(entry) => {
119 // Prevent infinite recursion on re-entry.
124 let item_id = self.tcx.hir.body_owner(body_id);
126 let outer_in_fn = self.in_fn;
127 self.in_fn = match MirSource::from_node(self.tcx, item_id) {
128 MirSource::Fn(_) => true,
132 let outer_tables = self.tables;
133 let item_def_id = self.tcx.hir.local_def_id(item_id);
134 self.tables = self.tcx.typeck_tables_of(item_def_id);
136 let body = self.tcx.hir.body(body_id);
138 self.check_const_eval(&body.value);
141 let outer_penv = self.tcx.infer_ctxt(body_id, Reveal::UserFacing).enter(|infcx| {
142 let param_env = infcx.param_env.clone();
143 let outer_penv = mem::replace(&mut self.param_env, param_env);
144 let region_maps = &self.tcx.region_maps(item_def_id);
145 euv::ExprUseVisitor::new(self, region_maps, &infcx).consume_body(body);
149 self.visit_body(body);
151 self.param_env = outer_penv;
152 self.tables = outer_tables;
153 self.in_fn = outer_in_fn;
156 fn visit_pat(&mut self, p: &'tcx hir::Pat) {
158 PatKind::Lit(ref lit) => {
159 self.check_const_eval(lit);
161 PatKind::Range(ref start, ref end, RangeEnd::Excluded) => {
162 let const_cx = ConstContext::with_tables(self.tcx, self.tables);
163 match const_cx.compare_lit_exprs(p.span, start, end) {
164 Ok(Ordering::Less) => {}
165 Ok(Ordering::Equal) |
166 Ok(Ordering::Greater) => {
167 span_err!(self.tcx.sess,
170 "lower range bound must be less than upper");
172 Err(ErrorReported) => {}
175 PatKind::Range(ref start, ref end, RangeEnd::Included) => {
176 let const_cx = ConstContext::with_tables(self.tcx, self.tables);
177 match const_cx.compare_lit_exprs(p.span, start, end) {
179 Ok(Ordering::Equal) => {}
180 Ok(Ordering::Greater) => {
181 struct_span_err!(self.tcx.sess, start.span, E0030,
182 "lower range bound must be less than or equal to upper")
183 .span_label(start.span, "lower bound larger than upper bound")
186 Err(ErrorReported) => {}
191 intravisit::walk_pat(self, p);
194 fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt) {
196 hir::StmtDecl(ref decl, _) => {
198 hir::DeclLocal(_) => {
199 self.promotable = false;
201 // Item statements are allowed
202 hir::DeclItem(_) => {}
206 hir::StmtSemi(..) => {
207 self.promotable = false;
210 intravisit::walk_stmt(self, stmt);
213 fn visit_expr(&mut self, ex: &'tcx hir::Expr) {
214 let outer = self.promotable;
215 self.promotable = true;
217 let node_ty = self.tables.node_id_to_type(ex.id);
218 check_expr(self, ex, node_ty);
219 check_adjustments(self, ex);
221 if let hir::ExprMatch(ref discr, ref arms, _) = ex.node {
222 // Compute the most demanding borrow from all the arms'
223 // patterns and set that on the discriminator.
224 let mut mut_borrow = false;
225 for pat in arms.iter().flat_map(|arm| &arm.pats) {
226 if self.mut_rvalue_borrows.remove(&pat.id) {
231 self.mut_rvalue_borrows.insert(discr.id);
235 intravisit::walk_expr(self, ex);
237 // Handle borrows on (or inside the autorefs of) this expression.
238 if self.mut_rvalue_borrows.remove(&ex.id) {
239 self.promotable = false;
242 if self.in_fn && self.promotable {
243 let const_cx = ConstContext::with_tables(self.tcx, self.tables);
244 match const_cx.eval(ex) {
246 Err(ConstEvalErr { kind: UnimplementedConstVal(_), .. }) |
247 Err(ConstEvalErr { kind: MiscCatchAll, .. }) |
248 Err(ConstEvalErr { kind: MiscBinaryOp, .. }) |
249 Err(ConstEvalErr { kind: NonConstPath, .. }) |
250 Err(ConstEvalErr { kind: ErroneousReferencedConstant(_), .. }) |
251 Err(ConstEvalErr { kind: Math(ConstMathErr::Overflow(Op::Shr)), .. }) |
252 Err(ConstEvalErr { kind: Math(ConstMathErr::Overflow(Op::Shl)), .. }) |
253 Err(ConstEvalErr { kind: IndexOpFeatureGated, .. }) => {}
254 Err(ConstEvalErr { kind: TypeckError, .. }) => {}
256 self.tcx.sess.add_lint(CONST_ERR,
259 msg.description().into_oneline().into_owned())
264 self.tcx.rvalue_promotable_to_static.borrow_mut().insert(ex.id, self.promotable);
265 self.promotable &= outer;
269 /// This function is used to enforce the constraints on
270 /// const/static items. It walks through the *value*
271 /// of the item walking down the expression and evaluating
272 /// every nested expression. If the expression is not part
273 /// of a const/static item, it is qualified for promotion
274 /// instead of producing errors.
275 fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr, node_ty: Ty<'tcx>) {
277 ty::TyAdt(def, _) if def.has_dtor(v.tcx) => {
278 v.promotable = false;
283 let method_call = ty::MethodCall::expr(e.id);
286 hir::ExprBinary(..) |
287 hir::ExprIndex(..) if v.tables.method_map.contains_key(&method_call) => {
288 v.promotable = false;
291 v.promotable = false;
293 hir::ExprUnary(op, ref inner) => {
294 match v.tables.node_id_to_type(inner.id).sty {
296 assert!(op == hir::UnDeref);
298 v.promotable = false;
303 hir::ExprBinary(op, ref lhs, _) => {
304 match v.tables.node_id_to_type(lhs.id).sty {
306 assert!(op.node == hir::BiEq || op.node == hir::BiNe ||
307 op.node == hir::BiLe || op.node == hir::BiLt ||
308 op.node == hir::BiGe || op.node == hir::BiGt);
310 v.promotable = false;
315 hir::ExprCast(ref from, _) => {
316 debug!("Checking const cast(id={})", from.id);
317 match v.tables.cast_kinds.get(&from.id) {
318 None => span_bug!(e.span, "no kind for cast"),
319 Some(&CastKind::PtrAddrCast) | Some(&CastKind::FnPtrAddrCast) => {
320 v.promotable = false;
325 hir::ExprPath(ref qpath) => {
326 let def = v.tables.qpath_def(qpath, e.id);
328 Def::VariantCtor(..) | Def::StructCtor(..) |
329 Def::Fn(..) | Def::Method(..) => {}
330 Def::AssociatedConst(_) => v.add_type(node_ty),
332 v.promotable &= if let Some(node_id) = v.tcx.hir.as_local_node_id(did) {
333 match v.tcx.hir.expect_item(node_id).node {
334 hir::ItemConst(_, body) => {
335 v.visit_nested_body(body);
336 v.tcx.rvalue_promotable_to_static.borrow()[&body.node_id]
341 v.tcx.const_is_rvalue_promotable_to_static(did)
345 v.promotable = false;
349 hir::ExprCall(ref callee, _) => {
350 let mut callee = &**callee;
352 callee = match callee.node {
353 hir::ExprBlock(ref block) => match block.expr {
354 Some(ref tail) => &tail,
360 // The callee is an arbitrary expression, it doesn't necessarily have a definition.
361 let def = if let hir::ExprPath(ref qpath) = callee.node {
362 v.tables.qpath_def(qpath, callee.id)
367 Def::StructCtor(_, CtorKind::Fn) |
368 Def::VariantCtor(_, CtorKind::Fn) => {}
370 v.handle_const_fn_call(did, node_ty)
372 Def::Method(did) => {
373 match v.tcx.associated_item(did).container {
374 ty::ImplContainer(_) => {
375 v.handle_const_fn_call(did, node_ty)
377 ty::TraitContainer(_) => v.promotable = false
380 _ => v.promotable = false
383 hir::ExprMethodCall(..) => {
384 let method = v.tables.method_map[&method_call];
385 match v.tcx.associated_item(method.def_id).container {
386 ty::ImplContainer(_) => v.handle_const_fn_call(method.def_id, node_ty),
387 ty::TraitContainer(_) => v.promotable = false
390 hir::ExprStruct(..) => {
391 if let ty::TyAdt(adt, ..) = v.tables.expr_ty(e).sty {
392 // unsafe_cell_type doesn't necessarily exist with no_core
393 if Some(adt.did) == v.tcx.lang_items.unsafe_cell_type() {
394 v.promotable = false;
400 hir::ExprAddrOf(..) |
401 hir::ExprRepeat(..) => {}
403 hir::ExprClosure(..) => {
404 // Paths in constant contexts cannot refer to local variables,
405 // as there are none, and thus closures can't have upvars there.
406 if v.tcx.with_freevars(e.id, |fv| !fv.is_empty()) {
407 v.promotable = false;
414 hir::ExprTupField(..) |
417 hir::ExprTup(..) => {}
419 // Conditional control flow (possible to implement).
423 // Loops (not very meaningful in constants).
427 // More control flow (also not very meaningful).
432 // Expressions with side-effects.
433 hir::ExprAssign(..) |
434 hir::ExprAssignOp(..) |
435 hir::ExprInlineAsm(..) => {
436 v.promotable = false;
441 /// Check the adjustments of an expression
442 fn check_adjustments<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr) {
443 use rustc::ty::adjustment::*;
445 match v.tables.adjustments.get(&e.id).map(|adj| adj.kind) {
447 Some(Adjust::NeverToAny) |
448 Some(Adjust::ReifyFnPointer) |
449 Some(Adjust::UnsafeFnPointer) |
450 Some(Adjust::ClosureFnPointer) |
451 Some(Adjust::MutToConstPointer) => {}
453 Some(Adjust::DerefRef { autoderefs, .. }) => {
454 if (0..autoderefs as u32)
455 .any(|autoderef| v.tables.is_overloaded_autoderef(e.id, autoderef)) {
456 v.promotable = false;
462 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
463 tcx.hir.krate().visit_all_item_likes(&mut CheckCrateVisitor {
465 tables: &ty::TypeckTables::empty(),
468 mut_rvalue_borrows: NodeSet(),
469 param_env: ty::ParamEnv::empty(),
470 }.as_deep_visitor());
471 tcx.sess.abort_if_errors();
474 impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'gcx> {
475 fn consume(&mut self,
476 _consume_id: ast::NodeId,
479 _mode: euv::ConsumeMode) {}
482 borrow_id: ast::NodeId,
485 _loan_region: ty::Region<'tcx>,
487 loan_cause: euv::LoanCause) {
488 // Kind of hacky, but we allow Unsafe coercions in constants.
489 // These occur when we convert a &T or *T to a *U, as well as
490 // when making a thin pointer (e.g., `*T`) into a fat pointer
493 euv::LoanCause::AutoUnsafe => {
502 Categorization::Rvalue(..) => {
503 if loan_cause == euv::MatchDiscriminant {
504 // Ignore the dummy immutable borrow created by EUV.
507 if bk.to_mutbl_lossy() == hir::MutMutable {
508 self.mut_rvalue_borrows.insert(borrow_id);
512 Categorization::StaticItem => {
515 Categorization::Deref(ref cmt, ..) |
516 Categorization::Downcast(ref cmt, _) |
517 Categorization::Interior(ref cmt, _) => {
521 Categorization::Upvar(..) |
522 Categorization::Local(..) => break,
527 fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) {}
529 _assignment_id: ast::NodeId,
530 _assignment_span: Span,
531 _assignee_cmt: mc::cmt,
532 _mode: euv::MutateMode) {
535 fn matched_pat(&mut self, _: &hir::Pat, _: mc::cmt, _: euv::MatchMode) {}
537 fn consume_pat(&mut self, _consume_pat: &hir::Pat, _cmt: mc::cmt, _mode: euv::ConsumeMode) {}