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::ParameterEnvironment<'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, Reveal::UserFacing).enter(|infcx| {
 142             let param_env = infcx.parameter_environment.clone();
 143             let outer_penv = mem::replace(&mut self.param_env, param_env);
 144             euv::ExprUseVisitor::new(self, item_def_id, &infcx).consume_body(body);
 145             outer_penv
 146         });
 147
 148         self.visit_body(body);
 149
 150         self.param_env = outer_penv;
 151         self.tables = outer_tables;
 152         self.in_fn = outer_in_fn;
 153     }
 154
 155     fn visit_pat(&mut self, p: &'tcx hir::Pat) {
 156         match p.node {
 157             PatKind::Lit(ref lit) => {
 158                 self.check_const_eval(lit);
 159             }
 160             PatKind::Range(ref start, ref end, RangeEnd::Excluded) => {
 161                 let const_cx = ConstContext::with_tables(self.tcx, self.tables);
 162                 match const_cx.compare_lit_exprs(p.span, start, end) {
 163                     Ok(Ordering::Less) => {}
 164                     Ok(Ordering::Equal) |
 165                     Ok(Ordering::Greater) => {
 166                         span_err!(self.tcx.sess,
 167                                   start.span,
 168                                   E0579,
 169                                   "lower range bound must be less than upper");
 170                     }
 171                     Err(ErrorReported) => {}
 172                 }
 173             }
 174             PatKind::Range(ref start, ref end, RangeEnd::Included) => {
 175                 let const_cx = ConstContext::with_tables(self.tcx, self.tables);
 176                 match const_cx.compare_lit_exprs(p.span, start, end) {
 177                     Ok(Ordering::Less) |
 178                     Ok(Ordering::Equal) => {}
 179                     Ok(Ordering::Greater) => {
 180                         struct_span_err!(self.tcx.sess, start.span, E0030,
 181                             "lower range bound must be less than or equal to upper")
 182                             .span_label(start.span, &format!("lower bound larger than upper bound"))
 183                             .emit();
 184                     }
 185                     Err(ErrorReported) => {}
 186                 }
 187             }
 188             _ => {}
 189         }
 190         intravisit::walk_pat(self, p);
 191     }
 192
 193     fn visit_stmt(&mut self, stmt: &'tcx hir::Stmt) {
 194         match stmt.node {
 195             hir::StmtDecl(ref decl, _) => {
 196                 match decl.node {
 197                     hir::DeclLocal(_) => {
 198                         self.promotable = false;
 199                     }
 200                     // Item statements are allowed
 201                     hir::DeclItem(_) => {}
 202                 }
 203             }
 204             hir::StmtExpr(..) |
 205             hir::StmtSemi(..) => {
 206                 self.promotable = false;
 207             }
 208         }
 209         intravisit::walk_stmt(self, stmt);
 210     }
 211
 212     fn visit_expr(&mut self, ex: &'tcx hir::Expr) {
 213         let outer = self.promotable;
 214         self.promotable = true;
 215
 216         let node_ty = self.tables.node_id_to_type(ex.id);
 217         check_expr(self, ex, node_ty);
 218         check_adjustments(self, ex);
 219
 220         if let hir::ExprMatch(ref discr, ref arms, _) = ex.node {
 221             // Compute the most demanding borrow from all the arms'
 222             // patterns and set that on the discriminator.
 223             let mut mut_borrow = false;
 224             for pat in arms.iter().flat_map(|arm| &arm.pats) {
 225                 if self.mut_rvalue_borrows.remove(&pat.id) {
 226                     mut_borrow = true;
 227                 }
 228             }
 229             if mut_borrow {
 230                 self.mut_rvalue_borrows.insert(discr.id);
 231             }
 232         }
 233
 234         intravisit::walk_expr(self, ex);
 235
 236         // Handle borrows on (or inside the autorefs of) this expression.
 237         if self.mut_rvalue_borrows.remove(&ex.id) {
 238             self.promotable = false;
 239         }
 240
 241         if self.in_fn && self.promotable {
 242             let const_cx = ConstContext::with_tables(self.tcx, self.tables);
 243             match const_cx.eval(ex) {
 244                 Ok(_) => {}
 245                 Err(ConstEvalErr { kind: UnimplementedConstVal(_), .. }) |
 246                 Err(ConstEvalErr { kind: MiscCatchAll, .. }) |
 247                 Err(ConstEvalErr { kind: MiscBinaryOp, .. }) |
 248                 Err(ConstEvalErr { kind: NonConstPath, .. }) |
 249                 Err(ConstEvalErr { kind: ErroneousReferencedConstant(_), .. }) |
 250                 Err(ConstEvalErr { kind: Math(ConstMathErr::Overflow(Op::Shr)), .. }) |
 251                 Err(ConstEvalErr { kind: Math(ConstMathErr::Overflow(Op::Shl)), .. }) |
 252                 Err(ConstEvalErr { kind: IndexOpFeatureGated, .. }) => {}
 253                 Err(ConstEvalErr { kind: TypeckError, .. }) => {}
 254                 Err(msg) => {
 255                     self.tcx.sess.add_lint(CONST_ERR,
 256                                            ex.id,
 257                                            msg.span,
 258                                            msg.description().into_oneline().into_owned())
 259                 }
 260             }
 261         }
 262
 263         self.tcx.rvalue_promotable_to_static.borrow_mut().insert(ex.id, self.promotable);
 264         self.promotable &= outer;
 265     }
 266 }
 267
 268 /// This function is used to enforce the constraints on
 269 /// const/static items. It walks through the *value*
 270 /// of the item walking down the expression and evaluating
 271 /// every nested expression. If the expression is not part
 272 /// of a const/static item, it is qualified for promotion
 273 /// instead of producing errors.
 274 fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr, node_ty: Ty<'tcx>) {
 275     match node_ty.sty {
 276         ty::TyAdt(def, _) if def.has_dtor(v.tcx) => {
 277             v.promotable = false;
 278         }
 279         _ => {}
 280     }
 281
 282     let method_call = ty::MethodCall::expr(e.id);
 283     match e.node {
 284         hir::ExprUnary(..) |
 285         hir::ExprBinary(..) |
 286         hir::ExprIndex(..) if v.tables.method_map.contains_key(&method_call) => {
 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.sess.cstore.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 method = v.tables.method_map[&method_call];
 384             match v.tcx.associated_item(method.def_id).container {
 385                 ty::ImplContainer(_) => v.handle_const_fn_call(method.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     match v.tables.adjustments.get(&e.id).map(|adj| adj.kind) {
 445         None |
 446         Some(Adjust::NeverToAny) |
 447         Some(Adjust::ReifyFnPointer) |
 448         Some(Adjust::UnsafeFnPointer) |
 449         Some(Adjust::ClosureFnPointer) |
 450         Some(Adjust::MutToConstPointer) => {}
 451
 452         Some(Adjust::DerefRef { autoderefs, .. }) => {
 453             if (0..autoderefs as u32)
 454                 .any(|autoderef| v.tables.is_overloaded_autoderef(e.id, autoderef)) {
 455                 v.promotable = false;
 456             }
 457         }
 458     }
 459 }
 460
 461 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
 462     tcx.hir.krate().visit_all_item_likes(&mut CheckCrateVisitor {
 463         tcx: tcx,
 464         tables: &ty::TypeckTables::empty(),
 465         in_fn: false,
 466         promotable: false,
 467         mut_rvalue_borrows: NodeSet(),
 468         param_env: tcx.empty_parameter_environment(),
 469     }.as_deep_visitor());
 470     tcx.sess.abort_if_errors();
 471 }
 472
 473 impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'gcx> {
 474     fn consume(&mut self,
 475                _consume_id: ast::NodeId,
 476                _consume_span: Span,
 477                _cmt: mc::cmt,
 478                _mode: euv::ConsumeMode) {}
 479
 480     fn borrow(&mut self,
 481               borrow_id: ast::NodeId,
 482               _borrow_span: Span,
 483               cmt: mc::cmt<'tcx>,
 484               _loan_region: ty::Region<'tcx>,
 485               bk: ty::BorrowKind,
 486               loan_cause: euv::LoanCause) {
 487         // Kind of hacky, but we allow Unsafe coercions in constants.
 488         // These occur when we convert a &T or *T to a *U, as well as
 489         // when making a thin pointer (e.g., `*T`) into a fat pointer
 490         // (e.g., `*Trait`).
 491         match loan_cause {
 492             euv::LoanCause::AutoUnsafe => {
 493                 return;
 494             }
 495             _ => {}
 496         }
 497
 498         let mut cur = &cmt;
 499         loop {
 500             match cur.cat {
 501                 Categorization::Rvalue(..) => {
 502                     if loan_cause == euv::MatchDiscriminant {
 503                         // Ignore the dummy immutable borrow created by EUV.
 504                         break;
 505                     }
 506                     if bk.to_mutbl_lossy() == hir::MutMutable {
 507                         self.mut_rvalue_borrows.insert(borrow_id);
 508                     }
 509                     break;
 510                 }
 511                 Categorization::StaticItem => {
 512                     break;
 513                 }
 514                 Categorization::Deref(ref cmt, ..) |
 515                 Categorization::Downcast(ref cmt, _) |
 516                 Categorization::Interior(ref cmt, _) => {
 517                     cur = cmt;
 518                 }
 519
 520                 Categorization::Upvar(..) |
 521                 Categorization::Local(..) => break,
 522             }
 523         }
 524     }
 525
 526     fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) {}
 527     fn mutate(&mut self,
 528               _assignment_id: ast::NodeId,
 529               _assignment_span: Span,
 530               _assignee_cmt: mc::cmt,
 531               _mode: euv::MutateMode) {
 532     }
 533
 534     fn matched_pat(&mut self, _: &hir::Pat, _: mc::cmt, _: euv::MatchMode) {}
 535
 536     fn consume_pat(&mut self, _consume_pat: &hir::Pat, _cmt: mc::cmt, _mode: euv::ConsumeMode) {}
 537 }