1 // Copyright 2016 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 //! A pass that qualifies constness of temporaries in constants,
12 //! static initializers and functions and also drives promotion.
14 //! The Qualif flags below can be used to also provide better
15 //! diagnostics as to why a constant rvalue wasn't promoted.
17 use rustc_data_structures::bitvec::BitVector;
18 use rustc_data_structures::indexed_vec::{IndexVec, Idx};
19 use rustc::dep_graph::DepNode;
21 use rustc::hir::def_id::DefId;
22 use rustc::hir::intravisit::FnKind;
23 use rustc::hir::map::blocks::FnLikeNode;
24 use rustc::traits::{self, Reveal};
25 use rustc::ty::{self, TyCtxt, Ty};
26 use rustc::ty::cast::CastTy;
27 use rustc::mir::repr::*;
28 use rustc::mir::mir_map::MirMap;
29 use rustc::mir::traversal::{self, ReversePostorder};
30 use rustc::mir::transform::{Pass, MirMapPass, MirPassHook, MirSource};
31 use rustc::mir::visit::{LvalueContext, Visitor};
32 use rustc::util::nodemap::DefIdMap;
34 use syntax::feature_gate::UnstableFeatures;
37 use std::collections::hash_map::Entry;
42 use super::promote_consts::{self, Candidate, TempState};
46 // Const item's qualification while recursing.
47 // Recursive consts are an error.
48 const RECURSIVE = 1 << 0,
50 // Constant containing interior mutability (UnsafeCell).
51 const MUTABLE_INTERIOR = 1 << 1,
53 // Constant containing an ADT that implements Drop.
54 const NEEDS_DROP = 1 << 2,
57 const FN_ARGUMENT = 1 << 3,
59 // Static lvalue or move from a static.
60 const STATIC = 1 << 4,
62 // Reference to a static.
63 const STATIC_REF = 1 << 5,
65 // Not constant at all - non-`const fn` calls, asm!,
66 // pointer comparisons, ptr-to-int casts, etc.
67 const NOT_CONST = 1 << 6,
69 // Refers to temporaries which cannot be promoted as
70 // promote_consts decided they weren't simple enough.
71 const NOT_PROMOTABLE = 1 << 7,
73 // Borrows of temporaries can be promoted only
74 // if they have none of the above qualifications.
75 const NEVER_PROMOTE = !0,
77 // Const items can only have MUTABLE_INTERIOR
78 // and NOT_PROMOTABLE without producing an error.
79 const CONST_ERROR = !Qualif::MUTABLE_INTERIOR.bits &
80 !Qualif::NOT_PROMOTABLE.bits
84 impl<'a, 'tcx> Qualif {
85 /// Remove flags which are impossible for the given type.
86 fn restrict(&mut self, ty: Ty<'tcx>,
87 tcx: TyCtxt<'a, 'tcx, 'tcx>,
88 param_env: &ty::ParameterEnvironment<'tcx>) {
89 if !ty.type_contents(tcx).interior_unsafe() {
90 *self = *self - Qualif::MUTABLE_INTERIOR;
92 if !tcx.type_needs_drop_given_env(ty, param_env) {
93 *self = *self - Qualif::NEEDS_DROP;
98 /// What kind of item we are in.
99 #[derive(Copy, Clone, PartialEq, Eq)]
108 impl fmt::Display for Mode {
109 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
111 Mode::Const => write!(f, "constant"),
112 Mode::Static | Mode::StaticMut => write!(f, "static"),
113 Mode::ConstFn => write!(f, "constant function"),
114 Mode::Fn => write!(f, "function")
119 fn is_const_fn(tcx: TyCtxt, def_id: DefId) -> bool {
120 if let Some(node_id) = tcx.map.as_local_node_id(def_id) {
121 let fn_like = FnLikeNode::from_node(tcx.map.get(node_id));
122 match fn_like.map(|f| f.kind()) {
123 Some(FnKind::ItemFn(_, _, _, c, _, _, _)) => {
124 c == hir::Constness::Const
126 Some(FnKind::Method(_, m, _, _)) => {
127 m.constness == hir::Constness::Const
132 tcx.sess.cstore.is_const_fn(def_id)
136 struct Qualifier<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
141 rpo: ReversePostorder<'a, 'tcx>,
142 tcx: TyCtxt<'a, 'gcx, 'tcx>,
143 param_env: ty::ParameterEnvironment<'tcx>,
144 qualif_map: &'a mut DefIdMap<Qualif>,
145 mir_map: Option<&'a MirMap<'tcx>>,
146 temp_qualif: IndexVec<Temp, Option<Qualif>>,
147 return_qualif: Option<Qualif>,
149 const_fn_arg_vars: BitVector,
151 temp_promotion_state: IndexVec<Temp, TempState>,
152 promotion_candidates: Vec<Candidate>
155 impl<'a, 'tcx> Qualifier<'a, 'tcx, 'tcx> {
156 fn new(tcx: TyCtxt<'a, 'tcx, 'tcx>,
157 param_env: ty::ParameterEnvironment<'tcx>,
158 qualif_map: &'a mut DefIdMap<Qualif>,
159 mir_map: Option<&'a MirMap<'tcx>>,
163 -> Qualifier<'a, 'tcx, 'tcx> {
164 let mut rpo = traversal::reverse_postorder(mir);
165 let temps = promote_consts::collect_temps(mir, &mut rpo);
174 param_env: param_env,
175 qualif_map: qualif_map,
177 temp_qualif: IndexVec::from_elem(None, &mir.temp_decls),
179 qualif: Qualif::empty(),
180 const_fn_arg_vars: BitVector::new(mir.var_decls.len()),
185 temp_promotion_state: temps,
186 promotion_candidates: vec![]
190 // FIXME(eddyb) we could split the errors into meaningful
191 // categories, but enabling full miri would make that
192 // slightly pointless (even with feature-gating).
193 fn not_const(&mut self) {
194 self.add(Qualif::NOT_CONST);
195 if self.mode != Mode::Fn {
196 span_err!(self.tcx.sess, self.span, E0019,
197 "{} contains unimplemented expression type", self.mode);
201 /// Error about extra statements in a constant.
202 fn statement_like(&mut self) {
203 self.add(Qualif::NOT_CONST);
204 if self.mode != Mode::Fn {
205 span_err!(self.tcx.sess, self.span, E0016,
206 "blocks in {}s are limited to items and tail expressions",
211 /// Add the given qualification to self.qualif.
212 fn add(&mut self, qualif: Qualif) {
213 self.qualif = self.qualif | qualif;
216 /// Add the given type's qualification to self.qualif.
217 fn add_type(&mut self, ty: Ty<'tcx>) {
218 self.add(Qualif::MUTABLE_INTERIOR | Qualif::NEEDS_DROP);
219 self.qualif.restrict(ty, self.tcx, &self.param_env);
222 /// Within the provided closure, self.qualif will start
223 /// out empty, and its value after the closure returns will
224 /// be combined with the value before the call to nest.
225 fn nest<F: FnOnce(&mut Self)>(&mut self, f: F) {
226 let original = self.qualif;
227 self.qualif = Qualif::empty();
232 /// Check for NEEDS_DROP (from an ADT or const fn call) and
233 /// error, unless we're in a function, or the feature-gate
234 /// for globals with destructors is enabled.
235 fn deny_drop(&self) {
236 if self.mode == Mode::Fn || !self.qualif.intersects(Qualif::NEEDS_DROP) {
240 // Static and const fn's allow destructors, but they're feature-gated.
241 let msg = if self.mode != Mode::Const {
242 // Feature-gate for globals with destructors is enabled.
243 if self.tcx.sess.features.borrow().drop_types_in_const {
247 // This comes from a macro that has #[allow_internal_unstable].
248 if self.tcx.sess.codemap().span_allows_unstable(self.span) {
252 format!("destructors in {}s are an unstable feature",
255 format!("{}s are not allowed to have destructors",
260 struct_span_err!(self.tcx.sess, self.span, E0493, "{}", msg);
261 if self.mode != Mode::Const {
263 "in Nightly builds, add `#![feature(drop_types_in_const)]` \
264 to the crate attributes to enable");
269 /// Check if an Lvalue with the current qualifications could
270 /// be consumed, by either an operand or a Deref projection.
271 fn try_consume(&mut self) -> bool {
272 if self.qualif.intersects(Qualif::STATIC) && self.mode != Mode::Fn {
273 let msg = if self.mode == Mode::Static ||
274 self.mode == Mode::StaticMut {
275 "cannot refer to other statics by value, use the \
276 address-of operator or a constant instead"
278 "cannot refer to statics by value, use a constant instead"
280 struct_span_err!(self.tcx.sess, self.span, E0394, "{}", msg)
281 .span_label(self.span, &format!("referring to another static by value"))
282 .note(&format!("use the address-of operator or a constant instead"))
285 // Replace STATIC with NOT_CONST to avoid further errors.
286 self.qualif = self.qualif - Qualif::STATIC;
287 self.add(Qualif::NOT_CONST);
295 /// Assign the current qualification to the given destination.
296 fn assign(&mut self, dest: &Lvalue<'tcx>) {
297 let qualif = self.qualif;
298 let span = self.span;
299 let store = |slot: &mut Option<Qualif>| {
301 span_bug!(span, "multiple assignments to {:?}", dest);
303 *slot = Some(qualif);
306 // Only handle promotable temps in non-const functions.
307 if self.mode == Mode::Fn {
308 if let Lvalue::Temp(index) = *dest {
309 if self.temp_promotion_state[index].is_promotable() {
310 store(&mut self.temp_qualif[index]);
317 Lvalue::Temp(index) => store(&mut self.temp_qualif[index]),
318 Lvalue::ReturnPointer => store(&mut self.return_qualif),
320 Lvalue::Projection(box Projection {
321 base: Lvalue::Temp(index),
322 elem: ProjectionElem::Deref
323 }) if self.mir.temp_decls[index].ty.is_unique()
324 && self.temp_qualif[index].map_or(false, |qualif| {
325 qualif.intersects(Qualif::NOT_CONST)
327 // Part of `box expr`, we should've errored
328 // already for the Box allocation Rvalue.
331 // This must be an explicit assignment.
333 // Catch more errors in the destination.
334 self.visit_lvalue(dest, LvalueContext::Store);
335 self.statement_like();
340 /// Qualify a whole const, static initializer or const fn.
341 fn qualify_const(&mut self) -> Qualif {
344 let mut seen_blocks = BitVector::new(mir.basic_blocks().len());
345 let mut bb = START_BLOCK;
347 seen_blocks.insert(bb.index());
349 self.visit_basic_block_data(bb, &mir[bb]);
351 let target = match mir[bb].terminator().kind {
352 TerminatorKind::Goto { target } |
353 // Drops are considered noops.
354 TerminatorKind::Drop { target, .. } |
355 TerminatorKind::Assert { target, .. } |
356 TerminatorKind::Call { destination: Some((_, target)), .. } => {
360 // Non-terminating calls cannot produce any value.
361 TerminatorKind::Call { destination: None, .. } => {
362 return Qualif::empty();
365 TerminatorKind::If {..} |
366 TerminatorKind::Switch {..} |
367 TerminatorKind::SwitchInt {..} |
368 TerminatorKind::DropAndReplace { .. } |
369 TerminatorKind::Resume |
370 TerminatorKind::Unreachable => None,
372 TerminatorKind::Return => {
373 // Check for unused values. This usually means
374 // there are extra statements in the AST.
375 for temp in mir.temp_decls.indices() {
376 if self.temp_qualif[temp].is_none() {
380 let state = self.temp_promotion_state[temp];
381 if let TempState::Defined { location, uses: 0 } = state {
382 let data = &mir[location.block];
383 let stmt_idx = location.statement_index;
385 // Get the span for the initialization.
386 let source_info = if stmt_idx < data.statements.len() {
387 data.statements[stmt_idx].source_info
389 data.terminator().source_info
391 self.span = source_info.span;
393 // Treat this as a statement in the AST.
394 self.statement_like();
398 // Make sure there are no extra unassigned variables.
399 self.qualif = Qualif::NOT_CONST;
400 for index in 0..mir.var_decls.len() {
401 if !self.const_fn_arg_vars.contains(index) {
402 self.assign(&Lvalue::Var(Var::new(index)));
412 Some(target) if !seen_blocks.contains(target.index()) => {
422 let return_ty = mir.return_ty;
423 self.qualif = self.return_qualif.unwrap_or(Qualif::NOT_CONST);
427 // Check for destructors in static mut.
428 self.add_type(return_ty);
432 // Account for errors in consts by using the
433 // conservative type qualification instead.
434 if self.qualif.intersects(Qualif::CONST_ERROR) {
435 self.qualif = Qualif::empty();
436 self.add_type(return_ty);
444 /// Accumulates an Rvalue or Call's effects in self.qualif.
445 /// For functions (constant or not), it also records
446 /// candidates for promotion in promotion_candidates.
447 impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> {
448 fn visit_lvalue(&mut self, lvalue: &Lvalue<'tcx>, context: LvalueContext) {
451 self.add(Qualif::FN_ARGUMENT);
454 self.add(Qualif::NOT_CONST);
456 Lvalue::Temp(index) => {
457 if !self.temp_promotion_state[index].is_promotable() {
458 self.add(Qualif::NOT_PROMOTABLE);
461 if let Some(qualif) = self.temp_qualif[index] {
467 Lvalue::Static(_) => {
468 self.add(Qualif::STATIC);
469 if self.mode == Mode::Const || self.mode == Mode::ConstFn {
470 span_err!(self.tcx.sess, self.span, E0013,
471 "{}s cannot refer to statics, use \
472 a constant instead", self.mode);
475 Lvalue::ReturnPointer => {
478 Lvalue::Projection(ref proj) => {
480 this.super_lvalue(lvalue, context);
482 ProjectionElem::Deref => {
483 if !this.try_consume() {
487 if this.qualif.intersects(Qualif::STATIC_REF) {
488 this.qualif = this.qualif - Qualif::STATIC_REF;
489 this.add(Qualif::STATIC);
492 let base_ty = proj.base.ty(this.mir, this.tcx).to_ty(this.tcx);
493 if let ty::TyRawPtr(_) = base_ty.sty {
494 this.add(Qualif::NOT_CONST);
495 if this.mode != Mode::Fn {
496 struct_span_err!(this.tcx.sess,
498 "raw pointers cannot be dereferenced in {}s",
500 .span_label(this.span,
501 &format!("dereference of raw pointer in constant"))
507 ProjectionElem::Field(..) |
508 ProjectionElem::Index(_) => {
509 if this.mode != Mode::Fn &&
510 this.qualif.intersects(Qualif::STATIC) {
511 span_err!(this.tcx.sess, this.span, E0494,
512 "cannot refer to the interior of another \
513 static, use a constant instead");
515 let ty = lvalue.ty(this.mir, this.tcx).to_ty(this.tcx);
516 this.qualif.restrict(ty, this.tcx, &this.param_env);
519 ProjectionElem::ConstantIndex {..} |
520 ProjectionElem::Subslice {..} |
521 ProjectionElem::Downcast(..) => {
530 fn visit_operand(&mut self, operand: &Operand<'tcx>) {
532 Operand::Consume(_) => {
534 this.super_operand(operand);
538 Operand::Constant(ref constant) => {
539 // Only functions and methods can have these types.
540 if let ty::TyFnDef(..) = constant.ty.sty {
544 if let Literal::Item { def_id, substs } = constant.literal {
545 // Don't peek inside generic (associated) constants.
546 if substs.types().next().is_some() {
547 self.add_type(constant.ty);
549 let qualif = qualify_const_item_cached(self.tcx,
556 // FIXME(eddyb) check recursive constants here,
557 // instead of rustc_passes::static_recursion.
558 if self.qualif.intersects(Qualif::RECURSIVE) {
559 span_bug!(constant.span,
560 "recursive constant wasn't caught earlier");
563 // Let `const fn` transitively have destructors,
564 // but they do get stopped in `const` or `static`.
565 if self.mode != Mode::ConstFn {
573 fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>) {
574 // Recurse through operands and lvalues.
575 self.super_rvalue(rvalue);
580 Rvalue::UnaryOp(..) |
581 Rvalue::CheckedBinaryOp(..) |
582 Rvalue::Cast(CastKind::ReifyFnPointer, _, _) |
583 Rvalue::Cast(CastKind::UnsafeFnPointer, _, _) |
584 Rvalue::Cast(CastKind::Unsize, _, _) => {}
587 // Static lvalues in consts would have errored already,
588 // don't treat length checks as reads from statics.
589 self.qualif = self.qualif - Qualif::STATIC;
592 Rvalue::Ref(_, kind, ref lvalue) => {
593 // Static lvalues in consts would have errored already,
594 // only keep track of references to them here.
595 if self.qualif.intersects(Qualif::STATIC) {
596 self.qualif = self.qualif - Qualif::STATIC;
597 self.add(Qualif::STATIC_REF);
600 let ty = lvalue.ty(self.mir, self.tcx).to_ty(self.tcx);
601 if kind == BorrowKind::Mut {
602 // In theory, any zero-sized value could be borrowed
603 // mutably without consequences. However, only &mut []
604 // is allowed right now, and only in functions.
605 let allow = if self.mode == Mode::StaticMut {
606 // Inside a `static mut`, &mut [...] is also allowed.
608 ty::TyArray(..) | ty::TySlice(_) => {
609 // Mutating can expose drops, be conservative.
616 } else if let ty::TyArray(_, 0) = ty.sty {
617 self.mode == Mode::Fn
623 self.add(Qualif::NOT_CONST);
624 if self.mode != Mode::Fn {
625 struct_span_err!(self.tcx.sess, self.span, E0017,
626 "references in {}s may only refer \
627 to immutable values", self.mode)
628 .span_label(self.span, &format!("{}s require immutable values",
634 // Constants cannot be borrowed if they contain interior mutability as
635 // it means that our "silent insertion of statics" could change
636 // initializer values (very bad).
637 if self.qualif.intersects(Qualif::MUTABLE_INTERIOR) {
638 // Replace MUTABLE_INTERIOR with NOT_CONST to avoid
639 // duplicate errors (from reborrowing, for example).
640 self.qualif = self.qualif - Qualif::MUTABLE_INTERIOR;
641 self.add(Qualif::NOT_CONST);
642 if self.mode != Mode::Fn {
643 span_err!(self.tcx.sess, self.span, E0492,
644 "cannot borrow a constant which contains \
645 interior mutability, create a static instead");
650 // We might have a candidate for promotion.
651 let candidate = Candidate::Ref(self.location);
652 if self.mode == Mode::Fn || self.mode == Mode::ConstFn {
653 if !self.qualif.intersects(Qualif::NEVER_PROMOTE) {
654 // We can only promote direct borrows of temps.
655 if let Lvalue::Temp(_) = *lvalue {
656 self.promotion_candidates.push(candidate);
662 Rvalue::Cast(CastKind::Misc, ref operand, cast_ty) => {
663 let operand_ty = operand.ty(self.mir, self.tcx);
664 let cast_in = CastTy::from_ty(operand_ty).expect("bad input type for cast");
665 let cast_out = CastTy::from_ty(cast_ty).expect("bad output type for cast");
666 match (cast_in, cast_out) {
667 (CastTy::Ptr(_), CastTy::Int(_)) |
668 (CastTy::FnPtr, CastTy::Int(_)) => {
669 self.add(Qualif::NOT_CONST);
670 if self.mode != Mode::Fn {
671 span_err!(self.tcx.sess, self.span, E0018,
672 "raw pointers cannot be cast to integers in {}s",
680 Rvalue::BinaryOp(op, ref lhs, _) => {
681 if let ty::TyRawPtr(_) = lhs.ty(self.mir, self.tcx).sty {
682 assert!(op == BinOp::Eq || op == BinOp::Ne ||
683 op == BinOp::Le || op == BinOp::Lt ||
684 op == BinOp::Ge || op == BinOp::Gt);
686 self.add(Qualif::NOT_CONST);
687 if self.mode != Mode::Fn {
689 self.tcx.sess, self.span, E0395,
690 "raw pointers cannot be compared in {}s",
694 &format!("comparing raw pointers in static"))
701 self.add(Qualif::NOT_CONST);
702 if self.mode != Mode::Fn {
703 struct_span_err!(self.tcx.sess, self.span, E0010,
704 "allocations are not allowed in {}s", self.mode)
705 .span_label(self.span, &format!("allocation not allowed in {}s", self.mode))
710 Rvalue::Aggregate(ref kind, _) => {
711 if let AggregateKind::Adt(def, _, _) = *kind {
713 self.add(Qualif::NEEDS_DROP);
717 if Some(def.did) == self.tcx.lang_items.unsafe_cell_type() {
718 let ty = rvalue.ty(self.mir, self.tcx).unwrap();
720 assert!(self.qualif.intersects(Qualif::MUTABLE_INTERIOR));
721 // Even if the value inside may not need dropping,
722 // mutating it would change that.
723 if !self.qualif.intersects(Qualif::NOT_CONST) {
730 Rvalue::InlineAsm {..} => {
736 fn visit_terminator_kind(&mut self, bb: BasicBlock, kind: &TerminatorKind<'tcx>) {
737 if let TerminatorKind::Call { ref func, ref args, ref destination, .. } = *kind {
738 self.visit_operand(func);
740 let fn_ty = func.ty(self.mir, self.tcx);
741 let (is_shuffle, is_const_fn) = match fn_ty.sty {
742 ty::TyFnDef(def_id, _, f) => {
743 (f.abi == Abi::PlatformIntrinsic &&
744 self.tcx.item_name(def_id).as_str().starts_with("simd_shuffle"),
745 is_const_fn(self.tcx, def_id))
750 for (i, arg) in args.iter().enumerate() {
752 this.visit_operand(arg);
753 if is_shuffle && i == 2 && this.mode == Mode::Fn {
754 let candidate = Candidate::ShuffleIndices(bb);
755 if !this.qualif.intersects(Qualif::NEVER_PROMOTE) {
756 this.promotion_candidates.push(candidate);
758 span_err!(this.tcx.sess, this.span, E0526,
759 "shuffle indices are not constant");
767 // We are in a const or static initializer,
768 if self.mode != Mode::Fn &&
770 // feature-gate is not enabled,
771 !self.tcx.sess.features.borrow().const_fn &&
773 // this doesn't come from a crate with the feature-gate enabled,
774 self.def_id.is_local() &&
776 // this doesn't come from a macro that has #[allow_internal_unstable]
777 !self.tcx.sess.codemap().span_allows_unstable(self.span)
779 let mut err = self.tcx.sess.struct_span_err(self.span,
780 "const fns are an unstable feature");
782 "in Nightly builds, add `#![feature(const_fn)]` \
783 to the crate attributes to enable");
787 self.qualif = Qualif::NOT_CONST;
788 if self.mode != Mode::Fn {
789 // FIXME(#24111) Remove this check when const fn stabilizes
790 let (msg, note) = if let UnstableFeatures::Disallow =
791 self.tcx.sess.opts.unstable_features {
792 (format!("calls in {}s are limited to \
793 struct and enum constructors",
795 Some("a limited form of compile-time function \
796 evaluation is available on a nightly \
797 compiler via `const fn`"))
799 (format!("calls in {}s are limited \
800 to constant functions, \
801 struct and enum constructors",
805 let mut err = struct_span_err!(self.tcx.sess, self.span, E0015, "{}", msg);
806 if let Some(note) = note {
807 err.span_note(self.span, note);
813 if let Some((ref dest, _)) = *destination {
814 // Avoid propagating irrelevant callee/argument qualifications.
815 if self.qualif.intersects(Qualif::CONST_ERROR) {
816 self.qualif = Qualif::NOT_CONST;
818 // Be conservative about the returned value of a const fn.
820 let ty = dest.ty(self.mir, tcx).to_ty(tcx);
821 self.qualif = Qualif::empty();
824 // Let `const fn` transitively have destructors,
825 // but they do get stopped in `const` or `static`.
826 if self.mode != Mode::ConstFn {
833 // Qualify any operands inside other terminators.
834 self.super_terminator_kind(bb, kind);
838 fn visit_assign(&mut self, _: BasicBlock, dest: &Lvalue<'tcx>, rvalue: &Rvalue<'tcx>) {
839 self.visit_rvalue(rvalue);
841 // Check the allowed const fn argument forms.
842 if let (Mode::ConstFn, &Lvalue::Var(index)) = (self.mode, dest) {
843 if self.const_fn_arg_vars.insert(index.index()) {
844 // Direct use of an argument is permitted.
845 if let Rvalue::Use(Operand::Consume(Lvalue::Arg(_))) = *rvalue {
849 // Avoid a generic error for other uses of arguments.
850 if self.qualif.intersects(Qualif::FN_ARGUMENT) {
851 let decl = &self.mir.var_decls[index];
852 span_err!(self.tcx.sess, decl.source_info.span, E0022,
853 "arguments of constant functions can only \
854 be immutable by-value bindings");
863 fn visit_source_info(&mut self, source_info: &SourceInfo) {
864 self.span = source_info.span;
867 fn visit_statement(&mut self, bb: BasicBlock, statement: &Statement<'tcx>) {
868 assert_eq!(self.location.block, bb);
870 this.visit_source_info(&statement.source_info);
871 match statement.kind {
872 StatementKind::Assign(ref lvalue, ref rvalue) => {
873 this.visit_assign(bb, lvalue, rvalue);
875 StatementKind::SetDiscriminant { .. } |
876 StatementKind::StorageLive(_) |
877 StatementKind::StorageDead(_) => {}
880 self.location.statement_index += 1;
883 fn visit_terminator(&mut self, bb: BasicBlock, terminator: &Terminator<'tcx>) {
884 assert_eq!(self.location.block, bb);
885 self.nest(|this| this.super_terminator(bb, terminator));
888 fn visit_basic_block_data(&mut self, bb: BasicBlock, data: &BasicBlockData<'tcx>) {
889 self.location.statement_index = 0;
890 self.location.block = bb;
891 self.super_basic_block_data(bb, data);
895 fn qualify_const_item_cached<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
896 qualif_map: &mut DefIdMap<Qualif>,
897 mir_map: Option<&MirMap<'tcx>>,
900 match qualif_map.entry(def_id) {
901 Entry::Occupied(entry) => return *entry.get(),
902 Entry::Vacant(entry) => {
903 // Guard against `const` recursion.
904 entry.insert(Qualif::RECURSIVE);
909 let param_env_and_mir = if def_id.is_local() {
910 mir_map.and_then(|map| map.map.get(&def_id)).map(|mir| {
911 let node_id = tcx.map.as_local_node_id(def_id).unwrap();
912 (ty::ParameterEnvironment::for_item(tcx, node_id), mir)
914 } else if let Some(mir) = tcx.sess.cstore.maybe_get_item_mir(tcx, def_id) {
915 // These should only be monomorphic constants.
917 Some((tcx.empty_parameter_environment(), &extern_mir))
922 let (param_env, mir) = param_env_and_mir.unwrap_or_else(|| {
923 bug!("missing constant MIR for {}", tcx.item_path_str(def_id))
926 let mut qualifier = Qualifier::new(tcx, param_env, qualif_map, mir_map,
927 def_id, mir, Mode::Const);
928 let qualif = qualifier.qualify_const();
929 qualifier.qualif_map.insert(def_id, qualif);
933 pub struct QualifyAndPromoteConstants;
935 impl Pass for QualifyAndPromoteConstants {}
937 impl<'tcx> MirMapPass<'tcx> for QualifyAndPromoteConstants {
938 fn run_pass<'a>(&mut self,
939 tcx: TyCtxt<'a, 'tcx, 'tcx>,
940 map: &mut MirMap<'tcx>,
941 hooks: &mut [Box<for<'s> MirPassHook<'s>>]) {
942 let mut qualif_map = DefIdMap();
944 // First, visit `const` items, potentially recursing, to get
945 // accurate MUTABLE_INTERIOR and NEEDS_DROP qualifications.
946 let keys = map.map.keys();
947 for &def_id in &keys {
948 let _task = tcx.dep_graph.in_task(DepNode::Mir(def_id));
949 let id = tcx.map.as_local_node_id(def_id).unwrap();
950 let src = MirSource::from_node(tcx, id);
951 if let MirSource::Const(_) = src {
952 qualify_const_item_cached(tcx, &mut qualif_map, Some(map), def_id);
956 // Then, handle everything else, without recursing,
957 // as the MIR map is not shared, since promotion
958 // in functions (including `const fn`) mutates it.
959 for &def_id in &keys {
960 let _task = tcx.dep_graph.in_task(DepNode::Mir(def_id));
961 let id = tcx.map.as_local_node_id(def_id).unwrap();
962 let src = MirSource::from_node(tcx, id);
963 let mode = match src {
964 MirSource::Fn(_) => {
965 if is_const_fn(tcx, def_id) {
971 MirSource::Const(_) => continue,
972 MirSource::Static(_, hir::MutImmutable) => Mode::Static,
973 MirSource::Static(_, hir::MutMutable) => Mode::StaticMut,
974 MirSource::Promoted(..) => bug!()
976 let param_env = ty::ParameterEnvironment::for_item(tcx, id);
978 let mir = map.map.get_mut(&def_id).unwrap();
979 for hook in &mut *hooks {
980 hook.on_mir_pass(tcx, src, mir, self, false);
983 if mode == Mode::Fn || mode == Mode::ConstFn {
984 // This is ugly because Qualifier holds onto mir,
985 // which can't be mutated until its scope ends.
986 let (temps, candidates) = {
987 let mut qualifier = Qualifier::new(tcx, param_env, &mut qualif_map,
988 None, def_id, mir, mode);
989 if mode == Mode::ConstFn {
990 // Enforce a constant-like CFG for `const fn`.
991 qualifier.qualify_const();
993 while let Some((bb, data)) = qualifier.rpo.next() {
994 qualifier.visit_basic_block_data(bb, data);
998 (qualifier.temp_promotion_state,
999 qualifier.promotion_candidates)
1002 // Do the actual promotion, now that we know what's viable.
1003 promote_consts::promote_candidates(mir, tcx, temps, candidates);
1005 let mut qualifier = Qualifier::new(tcx, param_env, &mut qualif_map,
1006 None, def_id, mir, mode);
1007 qualifier.qualify_const();
1010 for hook in &mut *hooks {
1011 hook.on_mir_pass(tcx, src, mir, self, true);
1014 // Statics must be Sync.
1015 if mode == Mode::Static {
1016 let ty = mir.return_ty;
1017 tcx.infer_ctxt(None, None, Reveal::NotSpecializable).enter(|infcx| {
1018 let cause = traits::ObligationCause::new(mir.span, id, traits::SharedStatic);
1019 let mut fulfillment_cx = traits::FulfillmentContext::new();
1020 fulfillment_cx.register_builtin_bound(&infcx, ty, ty::BoundSync, cause);
1021 if let Err(err) = fulfillment_cx.select_all_or_error(&infcx) {
1022 infcx.report_fulfillment_errors(&err);
1025 if let Err(errors) = fulfillment_cx.select_rfc1592_obligations(&infcx) {
1026 infcx.report_fulfillment_errors_as_warnings(&errors, id);