compiler/rustc_mir/src/transform/check_consts/mod.rs

   1 //! Check the bodies of `const`s, `static`s and `const fn`s for illegal operations.
   2 //!
   3 //! This module will eventually replace the parts of `qualify_consts.rs` that check whether a local
   4 //! has interior mutability or needs to be dropped, as well as the visitor that emits errors when
   5 //! it finds operations that are invalid in a certain context.
   6
   7 use rustc_attr as attr;
   8 use rustc_hir as hir;
   9 use rustc_hir::def_id::{DefId, LocalDefId};
  10 use rustc_middle::mir;
  11 use rustc_middle::ty::{self, TyCtxt};
  12 use rustc_span::Symbol;
  13
  14 pub use self::qualifs::Qualif;
  15
  16 mod ops;
  17 pub mod post_drop_elaboration;
  18 pub mod qualifs;
  19 mod resolver;
  20 pub mod validation;
  21
  22 /// Information about the item currently being const-checked, as well as a reference to the global
  23 /// context.
  24 pub struct ConstCx<'mir, 'tcx> {
  25     pub body: &'mir mir::Body<'tcx>,
  26     pub tcx: TyCtxt<'tcx>,
  27     pub param_env: ty::ParamEnv<'tcx>,
  28     pub const_kind: Option<hir::ConstContext>,
  29 }
  30
  31 impl ConstCx<'mir, 'tcx> {
  32     pub fn new(tcx: TyCtxt<'tcx>, body: &'mir mir::Body<'tcx>) -> Self {
  33         let def_id = body.source.def_id().expect_local();
  34         let param_env = tcx.param_env(def_id);
  35         Self::new_with_param_env(tcx, body, param_env)
  36     }
  37
  38     pub fn new_with_param_env(
  39         tcx: TyCtxt<'tcx>,
  40         body: &'mir mir::Body<'tcx>,
  41         param_env: ty::ParamEnv<'tcx>,
  42     ) -> Self {
  43         let const_kind = tcx.hir().body_const_context(body.source.def_id().expect_local());
  44         ConstCx { body, tcx, param_env, const_kind }
  45     }
  46
  47     pub fn def_id(&self) -> LocalDefId {
  48         self.body.source.def_id().expect_local()
  49     }
  50
  51     /// Returns the kind of const context this `Item` represents (`const`, `static`, etc.).
  52     ///
  53     /// Panics if this `Item` is not const.
  54     pub fn const_kind(&self) -> hir::ConstContext {
  55         self.const_kind.expect("`const_kind` must not be called on a non-const fn")
  56     }
  57
  58     pub fn is_const_stable_const_fn(&self) -> bool {
  59         self.const_kind == Some(hir::ConstContext::ConstFn)
  60             && self.tcx.features().staged_api
  61             && is_const_stable_const_fn(self.tcx, self.def_id().to_def_id())
  62     }
  63
  64     /// Returns the function signature of the item being const-checked if it is a `fn` or `const fn`.
  65     pub fn fn_sig(&self) -> Option<&'tcx hir::FnSig<'tcx>> {
  66         // Get this from the HIR map instead of a query to avoid cycle errors.
  67         //
  68         // FIXME: Is this still an issue?
  69         let hir_map = self.tcx.hir();
  70         let hir_id = hir_map.local_def_id_to_hir_id(self.def_id());
  71         hir_map.fn_sig_by_hir_id(hir_id)
  72     }
  73 }
  74
  75 /// Returns `true` if this `DefId` points to one of the official `panic` lang items.
  76 pub fn is_lang_panic_fn(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
  77     Some(def_id) == tcx.lang_items().panic_fn()
  78         || Some(def_id) == tcx.lang_items().panic_str()
  79         || Some(def_id) == tcx.lang_items().begin_panic_fn()
  80 }
  81
  82 pub fn rustc_allow_const_fn_unstable(
  83     tcx: TyCtxt<'tcx>,
  84     def_id: DefId,
  85     feature_gate: Symbol,
  86 ) -> bool {
  87     let attrs = tcx.get_attrs(def_id);
  88     attr::rustc_allow_const_fn_unstable(&tcx.sess, attrs).any(|name| name == feature_gate)
  89 }
  90
  91 // Returns `true` if the given `const fn` is "const-stable".
  92 //
  93 // Panics if the given `DefId` does not refer to a `const fn`.
  94 //
  95 // Const-stability is only relevant for `const fn` within a `staged_api` crate. Only "const-stable"
  96 // functions can be called in a const-context by users of the stable compiler. "const-stable"
  97 // functions are subject to more stringent restrictions than "const-unstable" functions: They
  98 // cannot use unstable features and can only call other "const-stable" functions.
  99 pub fn is_const_stable_const_fn(tcx: TyCtxt<'tcx>, def_id: DefId) -> bool {
 100     use attr::{ConstStability, Stability, StabilityLevel};
 101
 102     // Const-stability is only relevant for `const fn`.
 103     assert!(tcx.is_const_fn_raw(def_id));
 104
 105     // Functions with `#[rustc_const_unstable]` are const-unstable.
 106     match tcx.lookup_const_stability(def_id) {
 107         Some(ConstStability { level: StabilityLevel::Unstable { .. }, .. }) => return false,
 108         Some(ConstStability { level: StabilityLevel::Stable { .. }, .. }) => return true,
 109         None => {}
 110     }
 111
 112     // Functions with `#[unstable]` are const-unstable.
 113     //
 114     // FIXME(ecstaticmorse): We should keep const-stability attributes wholly separate from normal stability
 115     // attributes. `#[unstable]` should be irrelevant.
 116     if let Some(Stability { level: StabilityLevel::Unstable { .. }, .. }) =
 117         tcx.lookup_stability(def_id)
 118     {
 119         return false;
 120     }
 121
 122     true
 123 }