src/librustc_passes/consts.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_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;
  46
  47 use rustc::hir::{self, PatKind, RangeEnd};
  48 use syntax::ast;
  49 use syntax_pos::{Span, DUMMY_SP};
  50 use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
  51
  52 use std::collections::hash_map::Entry;
  53 use std::cmp::Ordering;
  54 use std::mem;
  55
  56 struct CheckCrateVisitor<'a, 'tcx: 'a> {
  57     tcx: TyCtxt<'a, 'tcx, 'tcx>,
  58     in_fn: bool,
  59     promotable: bool,
  60     mut_rvalue_borrows: NodeSet,
  61     param_env: ty::ParamEnv<'tcx>,
  62     tables: &'a ty::TypeckTables<'tcx>,
  63 }
  64
  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) {
  69             match err.kind {
  70                 UnimplementedConstVal(_) => {}
  71                 IndexOpFeatureGated => {}
  72                 ErroneousReferencedConstant(_) => {}
  73                 TypeckError => {}
  74                 _ => {
  75                     self.tcx.sess.add_lint(CONST_ERR,
  76                                            expr.id,
  77                                            expr.span,
  78                                            format!("constant evaluation error: {}. This will \
  79                                                     become a HARD ERROR in the future",
  80                                                    err.description().into_oneline()))
  81                 }
  82             }
  83         }
  84     }
  85
  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;
  90         }
  91
  92         if ty.needs_drop(self.tcx, self.param_env) {
  93             self.promotable = false;
  94         }
  95     }
  96
  97     fn handle_const_fn_call(&mut self, def_id: DefId, ret_ty: Ty<'gcx>) {
  98         self.add_type(ret_ty);
  99
 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
 103             })
 104         } else {
 105             self.tcx.sess.cstore.is_const_fn(def_id)
 106         };
 107     }
 108 }
 109
 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
 113     }
 114
 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.
 120                 entry.insert(false);
 121             }
 122         }
 123
 124         let item_id = self.tcx.hir.body_owner(body_id);
 125
 126         let outer_in_fn = self.in_fn;
 127         self.in_fn = match MirSource::from_node(self.tcx, item_id) {
 128             MirSource::Fn(_) => true,
 129             _ => false
 130         };
 131
 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);
 135
 136         let body = self.tcx.hir.body(body_id);
 137         if !self.in_fn {
 138             self.check_const_eval(&body.value);
 139         }
 140
 141         let outer_penv = self.tcx.infer_ctxt(body_id).enter(|infcx| {
 142             let param_env = self.tcx.param_env(item_def_id);
 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, param_env).consume_body(body);
 146             outer_penv
 147         });
 148
 149         self.visit_body(body);
 150
 151         self.param_env = outer_penv;
 152         self.tables = outer_tables;
 153         self.in_fn = outer_in_fn;
 154     }
 155
 156     fn visit_pat(&mut self, p: &'tcx hir::Pat) {
 157         match p.node {
 158             PatKind::Lit(ref lit) => {
 159                 self.check_const_eval(lit);
 160             }
 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,
 168                                   start.span,
 169                                   E0579,
 170                                   "lower range bound must be less than upper");
 171                     }
 172                     Err(ErrorReported) => {}
 173                 }
 174             }
 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) {
 178                     Ok(Ordering::Less) |
 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")
 184                             .emit();
 185                     }
 186                     Err(ErrorReported) => {}
 187                 }
 188             }
 189             _ => {}
 190         }
 191         intravisit::walk_pat(self, p);
 192     }
 193
 194     fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt) {
 195         match stmt.node {
 196             hir::StmtDecl(ref decl, _) => {
 197                 match decl.node {
 198                     hir::DeclLocal(_) => {
 199                         self.promotable = false;
 200                     }
 201                     // Item statements are allowed
 202                     hir::DeclItem(_) => {}
 203                 }
 204             }
 205             hir::StmtExpr(..) |
 206             hir::StmtSemi(..) => {
 207                 self.promotable = false;
 208             }
 209         }
 210         intravisit::walk_stmt(self, stmt);
 211     }
 212
 213     fn visit_expr(&mut self, ex: &'tcx hir::Expr) {
 214         let outer = self.promotable;
 215         self.promotable = true;
 216
 217         let node_ty = self.tables.node_id_to_type(ex.id);
 218         check_expr(self, ex, node_ty);
 219         check_adjustments(self, ex);
 220
 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) {
 227                     mut_borrow = true;
 228                 }
 229             }
 230             if mut_borrow {
 231                 self.mut_rvalue_borrows.insert(discr.id);
 232             }
 233         }
 234
 235         intravisit::walk_expr(self, ex);
 236
 237         // Handle borrows on (or inside the autorefs of) this expression.
 238         if self.mut_rvalue_borrows.remove(&ex.id) {
 239             self.promotable = false;
 240         }
 241
 242         if self.in_fn && self.promotable {
 243             let const_cx = ConstContext::with_tables(self.tcx, self.tables);
 244             match const_cx.eval(ex) {
 245                 Ok(_) => {}
 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, .. }) => {}
 255                 Err(msg) => {
 256                     self.tcx.sess.add_lint(CONST_ERR,
 257                                            ex.id,
 258                                            msg.span,
 259                                            msg.description().into_oneline().into_owned())
 260                 }
 261             }
 262         }
 263
 264         self.tcx.rvalue_promotable_to_static.borrow_mut().insert(ex.id, self.promotable);
 265         self.promotable &= outer;
 266     }
 267 }
 268
 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>) {
 276     match node_ty.sty {
 277         ty::TyAdt(def, _) if def.has_dtor(v.tcx) => {
 278             v.promotable = false;
 279         }
 280         _ => {}
 281     }
 282
 283     match e.node {
 284         hir::ExprUnary(..) |
 285         hir::ExprBinary(..) |
 286         hir::ExprIndex(..) if v.tables.is_method_call(e) => {
 287             v.promotable = false;
 288         }
 289         hir::ExprBox(_) => {
 290             v.promotable = false;
 291         }
 292         hir::ExprUnary(op, ref inner) => {
 293             match v.tables.node_id_to_type(inner.id).sty {
 294                 ty::TyRawPtr(_) => {
 295                     assert!(op == hir::UnDeref);
 296
 297                     v.promotable = false;
 298                 }
 299                 _ => {}
 300             }
 301         }
 302         hir::ExprBinary(op, ref lhs, _) => {
 303             match v.tables.node_id_to_type(lhs.id).sty {
 304                 ty::TyRawPtr(_) => {
 305                     assert!(op.node == hir::BiEq || op.node == hir::BiNe ||
 306                             op.node == hir::BiLe || op.node == hir::BiLt ||
 307                             op.node == hir::BiGe || op.node == hir::BiGt);
 308
 309                     v.promotable = false;
 310                 }
 311                 _ => {}
 312             }
 313         }
 314         hir::ExprCast(ref from, _) => {
 315             debug!("Checking const cast(id={})", from.id);
 316             match v.tables.cast_kinds.get(&from.id) {
 317                 None => span_bug!(e.span, "no kind for cast"),
 318                 Some(&CastKind::PtrAddrCast) | Some(&CastKind::FnPtrAddrCast) => {
 319                     v.promotable = false;
 320                 }
 321                 _ => {}
 322             }
 323         }
 324         hir::ExprPath(ref qpath) => {
 325             let def = v.tables.qpath_def(qpath, e.id);
 326             match def {
 327                 Def::VariantCtor(..) | Def::StructCtor(..) |
 328                 Def::Fn(..) | Def::Method(..) => {}
 329                 Def::AssociatedConst(_) => v.add_type(node_ty),
 330                 Def::Const(did) => {
 331                     v.promotable &= if let Some(node_id) = v.tcx.hir.as_local_node_id(did) {
 332                         match v.tcx.hir.expect_item(node_id).node {
 333                             hir::ItemConst(_, body) => {
 334                                 v.visit_nested_body(body);
 335                                 v.tcx.rvalue_promotable_to_static.borrow()[&body.node_id]
 336                             }
 337                             _ => false
 338                         }
 339                     } else {
 340                         v.tcx.const_is_rvalue_promotable_to_static(did)
 341                     };
 342                 }
 343                 _ => {
 344                     v.promotable = false;
 345                 }
 346             }
 347         }
 348         hir::ExprCall(ref callee, _) => {
 349             let mut callee = &**callee;
 350             loop {
 351                 callee = match callee.node {
 352                     hir::ExprBlock(ref block) => match block.expr {
 353                         Some(ref tail) => &tail,
 354                         None => break
 355                     },
 356                     _ => break
 357                 };
 358             }
 359             // The callee is an arbitrary expression, it doesn't necessarily have a definition.
 360             let def = if let hir::ExprPath(ref qpath) = callee.node {
 361                 v.tables.qpath_def(qpath, callee.id)
 362             } else {
 363                 Def::Err
 364             };
 365             match def {
 366                 Def::StructCtor(_, CtorKind::Fn) |
 367                 Def::VariantCtor(_, CtorKind::Fn) => {}
 368                 Def::Fn(did) => {
 369                     v.handle_const_fn_call(did, node_ty)
 370                 }
 371                 Def::Method(did) => {
 372                     match v.tcx.associated_item(did).container {
 373                         ty::ImplContainer(_) => {
 374                             v.handle_const_fn_call(did, node_ty)
 375                         }
 376                         ty::TraitContainer(_) => v.promotable = false
 377                     }
 378                 }
 379                 _ => v.promotable = false
 380             }
 381         }
 382         hir::ExprMethodCall(..) => {
 383             let def_id = v.tables.type_dependent_defs[&e.id].def_id();
 384             match v.tcx.associated_item(def_id).container {
 385                 ty::ImplContainer(_) => v.handle_const_fn_call(def_id, node_ty),
 386                 ty::TraitContainer(_) => v.promotable = false
 387             }
 388         }
 389         hir::ExprStruct(..) => {
 390             if let ty::TyAdt(adt, ..) = v.tables.expr_ty(e).sty {
 391                 // unsafe_cell_type doesn't necessarily exist with no_core
 392                 if Some(adt.did) == v.tcx.lang_items.unsafe_cell_type() {
 393                     v.promotable = false;
 394                 }
 395             }
 396         }
 397
 398         hir::ExprLit(_) |
 399         hir::ExprAddrOf(..) |
 400         hir::ExprRepeat(..) => {}
 401
 402         hir::ExprClosure(..) => {
 403             // Paths in constant contexts cannot refer to local variables,
 404             // as there are none, and thus closures can't have upvars there.
 405             if v.tcx.with_freevars(e.id, |fv| !fv.is_empty()) {
 406                 v.promotable = false;
 407             }
 408         }
 409
 410         hir::ExprBlock(_) |
 411         hir::ExprIndex(..) |
 412         hir::ExprField(..) |
 413         hir::ExprTupField(..) |
 414         hir::ExprArray(_) |
 415         hir::ExprType(..) |
 416         hir::ExprTup(..) => {}
 417
 418         // Conditional control flow (possible to implement).
 419         hir::ExprMatch(..) |
 420         hir::ExprIf(..) |
 421
 422         // Loops (not very meaningful in constants).
 423         hir::ExprWhile(..) |
 424         hir::ExprLoop(..) |
 425
 426         // More control flow (also not very meaningful).
 427         hir::ExprBreak(..) |
 428         hir::ExprAgain(_) |
 429         hir::ExprRet(_) |
 430
 431         // Expressions with side-effects.
 432         hir::ExprAssign(..) |
 433         hir::ExprAssignOp(..) |
 434         hir::ExprInlineAsm(..) => {
 435             v.promotable = false;
 436         }
 437     }
 438 }
 439
 440 /// Check the adjustments of an expression
 441 fn check_adjustments<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr) {
 442     use rustc::ty::adjustment::*;
 443
 444     for adjustment in v.tables.expr_adjustments(e) {
 445         match adjustment.kind {
 446             Adjust::NeverToAny |
 447             Adjust::ReifyFnPointer |
 448             Adjust::UnsafeFnPointer |
 449             Adjust::ClosureFnPointer |
 450             Adjust::MutToConstPointer |
 451             Adjust::Borrow(_) |
 452             Adjust::Unsize => {}
 453
 454             Adjust::Deref(ref overloaded) => {
 455                 if overloaded.is_some() {
 456                     v.promotable = false;
 457                     break;
 458                 }
 459             }
 460         }
 461     }
 462 }
 463
 464 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
 465     tcx.hir.krate().visit_all_item_likes(&mut CheckCrateVisitor {
 466         tcx: tcx,
 467         tables: &ty::TypeckTables::empty(),
 468         in_fn: false,
 469         promotable: false,
 470         mut_rvalue_borrows: NodeSet(),
 471         param_env: ty::ParamEnv::empty(Reveal::UserFacing),
 472     }.as_deep_visitor());
 473     tcx.sess.abort_if_errors();
 474 }
 475
 476 impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'gcx> {
 477     fn consume(&mut self,
 478                _consume_id: ast::NodeId,
 479                _consume_span: Span,
 480                _cmt: mc::cmt,
 481                _mode: euv::ConsumeMode) {}
 482
 483     fn borrow(&mut self,
 484               borrow_id: ast::NodeId,
 485               _borrow_span: Span,
 486               cmt: mc::cmt<'tcx>,
 487               _loan_region: ty::Region<'tcx>,
 488               bk: ty::BorrowKind,
 489               loan_cause: euv::LoanCause) {
 490         // Kind of hacky, but we allow Unsafe coercions in constants.
 491         // These occur when we convert a &T or *T to a *U, as well as
 492         // when making a thin pointer (e.g., `*T`) into a fat pointer
 493         // (e.g., `*Trait`).
 494         match loan_cause {
 495             euv::LoanCause::AutoUnsafe => {
 496                 return;
 497             }
 498             _ => {}
 499         }
 500
 501         let mut cur = &cmt;
 502         loop {
 503             match cur.cat {
 504                 Categorization::Rvalue(..) => {
 505                     if loan_cause == euv::MatchDiscriminant {
 506                         // Ignore the dummy immutable borrow created by EUV.
 507                         break;
 508                     }
 509                     if bk.to_mutbl_lossy() == hir::MutMutable {
 510                         self.mut_rvalue_borrows.insert(borrow_id);
 511                     }
 512                     break;
 513                 }
 514                 Categorization::StaticItem => {
 515                     break;
 516                 }
 517                 Categorization::Deref(ref cmt, _) |
 518                 Categorization::Downcast(ref cmt, _) |
 519                 Categorization::Interior(ref cmt, _) => {
 520                     cur = cmt;
 521                 }
 522
 523                 Categorization::Upvar(..) |
 524                 Categorization::Local(..) => break,
 525             }
 526         }
 527     }
 528
 529     fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) {}
 530     fn mutate(&mut self,
 531               _assignment_id: ast::NodeId,
 532               _assignment_span: Span,
 533               _assignee_cmt: mc::cmt,
 534               _mode: euv::MutateMode) {
 535     }
 536
 537     fn matched_pat(&mut self, _: &hir::Pat, _: mc::cmt, _: euv::MatchMode) {}
 538
 539     fn consume_pat(&mut self, _consume_pat: &hir::Pat, _cmt: mc::cmt, _mode: euv::ConsumeMode) {}
 540 }