src/librustc_passes/check_const.rs

   1 //! This pass checks HIR bodies that may be evaluated at compile-time (e.g., `const`, `static`,
   2 //! `const fn`) for structured control flow (e.g. `if`, `while`), which is forbidden in a const
   3 //! context.
   4 //!
   5 //! By the time the MIR const-checker runs, these high-level constructs have been lowered to
   6 //! control-flow primitives (e.g., `Goto`, `SwitchInt`), making it tough to properly attribute
   7 //! errors. We still look for those primitives in the MIR const-checker to ensure nothing slips
   8 //! through, but errors for structured control flow in a `const` should be emitted here.
   9
  10 use rustc::hir::def_id::DefId;
  11 use rustc::hir::intravisit::{Visitor, NestedVisitorMap};
  12 use rustc::hir::map::Map;
  13 use rustc::hir;
  14 use rustc::session::Session;
  15 use rustc::ty::TyCtxt;
  16 use rustc::ty::query::Providers;
  17 use syntax::ast::Mutability;
  18 use syntax::span_err;
  19 use syntax_pos::Span;
  20 use rustc_error_codes::*;
  21
  22 use std::fmt;
  23
  24 #[derive(Copy, Clone)]
  25 enum ConstKind {
  26     Static,
  27     StaticMut,
  28     ConstFn,
  29     Const,
  30     AnonConst,
  31 }
  32
  33 impl ConstKind {
  34     fn for_body(body: &hir::Body, hir_map: &Map<'_>) -> Option<Self> {
  35         let is_const_fn = |id| hir_map.fn_sig_by_hir_id(id).unwrap().header.is_const();
  36
  37         let owner = hir_map.body_owner(body.id());
  38         let const_kind = match hir_map.body_owner_kind(owner) {
  39             hir::BodyOwnerKind::Const => Self::Const,
  40             hir::BodyOwnerKind::Static(Mutability::Mutable) => Self::StaticMut,
  41             hir::BodyOwnerKind::Static(Mutability::Immutable) => Self::Static,
  42
  43             hir::BodyOwnerKind::Fn if is_const_fn(owner) => Self::ConstFn,
  44             hir::BodyOwnerKind::Fn | hir::BodyOwnerKind::Closure => return None,
  45         };
  46
  47         Some(const_kind)
  48     }
  49 }
  50
  51 impl fmt::Display for ConstKind {
  52     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  53         let s = match self {
  54             Self::Static => "static",
  55             Self::StaticMut => "static mut",
  56             Self::Const | Self::AnonConst => "const",
  57             Self::ConstFn => "const fn",
  58         };
  59
  60         write!(f, "{}", s)
  61     }
  62 }
  63
  64 fn check_mod_const_bodies(tcx: TyCtxt<'_>, module_def_id: DefId) {
  65     let mut vis = CheckConstVisitor::new(tcx);
  66     tcx.hir().visit_item_likes_in_module(module_def_id, &mut vis.as_deep_visitor());
  67 }
  68
  69 pub(crate) fn provide(providers: &mut Providers<'_>) {
  70     *providers = Providers {
  71         check_mod_const_bodies,
  72         ..*providers
  73     };
  74 }
  75
  76 #[derive(Copy, Clone)]
  77 struct CheckConstVisitor<'tcx> {
  78     sess: &'tcx Session,
  79     hir_map: &'tcx Map<'tcx>,
  80     const_kind: Option<ConstKind>,
  81 }
  82
  83 impl<'tcx> CheckConstVisitor<'tcx> {
  84     fn new(tcx: TyCtxt<'tcx>) -> Self {
  85         CheckConstVisitor {
  86             sess: &tcx.sess,
  87             hir_map: tcx.hir(),
  88             const_kind: None,
  89         }
  90     }
  91
  92     /// Emits an error when an unsupported expression is found in a const context.
  93     fn const_check_violated(&self, bad_op: &str, span: Span) {
  94         if self.sess.opts.debugging_opts.unleash_the_miri_inside_of_you {
  95             self.sess.span_warn(span, "skipping const checks");
  96             return;
  97         }
  98
  99         let const_kind = self.const_kind
 100             .expect("`const_check_violated` may only be called inside a const context");
 101
 102         span_err!(self.sess, span, E0744, "`{}` is not allowed in a `{}`", bad_op, const_kind);
 103     }
 104
 105     /// Saves the parent `const_kind` before calling `f` and restores it afterwards.
 106     fn recurse_into(&mut self, kind: Option<ConstKind>, f: impl FnOnce(&mut Self)) {
 107         let parent_kind = self.const_kind;
 108         self.const_kind = kind;
 109         f(self);
 110         self.const_kind = parent_kind;
 111     }
 112 }
 113
 114 impl<'tcx> Visitor<'tcx> for CheckConstVisitor<'tcx> {
 115     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
 116         NestedVisitorMap::OnlyBodies(&self.hir_map)
 117     }
 118
 119     fn visit_anon_const(&mut self, anon: &'tcx hir::AnonConst) {
 120         let kind = Some(ConstKind::AnonConst);
 121         self.recurse_into(kind, |this| hir::intravisit::walk_anon_const(this, anon));
 122     }
 123
 124     fn visit_body(&mut self, body: &'tcx hir::Body) {
 125         let kind = ConstKind::for_body(body, self.hir_map);
 126         self.recurse_into(kind, |this| hir::intravisit::walk_body(this, body));
 127     }
 128
 129     fn visit_expr(&mut self, e: &'tcx hir::Expr) {
 130         match &e.kind {
 131             // Skip the following checks if we are not currently in a const context.
 132             _ if self.const_kind.is_none() => {}
 133
 134             hir::ExprKind::Loop(_, _, source) => {
 135                 self.const_check_violated(source.name(), e.span);
 136             }
 137
 138             hir::ExprKind::Match(_, _, source) if !self.tcx.features().const_if_match => {
 139                 use hir::MatchSource::*;
 140
 141                 let op = match source {
 142                     Normal => Some("match"),
 143                     IfDesugar { .. } | IfLetDesugar { .. } => Some("if"),
 144                     TryDesugar => Some("?"),
 145                     AwaitDesugar => Some(".await"),
 146
 147                     // These are handled by `ExprKind::Loop` above.
 148                     WhileDesugar | WhileLetDesugar | ForLoopDesugar => None,
 149                 };
 150
 151                 if let Some(op) = op {
 152                     self.const_check_violated(op, e.span);
 153                 }
 154             }
 155
 156             _ => {},
 157         }
 158
 159         hir::intravisit::walk_expr(self, e);
 160     }
 161 }