]>
Commit | Line | Data |
---|---|---|
60c5eb7d XL |
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 | ||
f035d41b | 10 | use rustc_attr as attr; |
dfeec247 | 11 | use rustc_hir as hir; |
f035d41b | 12 | use rustc_hir::def_id::LocalDefId; |
5099ac24 FG |
13 | use rustc_hir::intravisit::{self, Visitor}; |
14 | use rustc_middle::hir::nested_filter; | |
ba9703b0 XL |
15 | use rustc_middle::ty::query::Providers; |
16 | use rustc_middle::ty::TyCtxt; | |
ba9703b0 | 17 | use rustc_session::parse::feature_err; |
dfeec247 | 18 | use rustc_span::{sym, Span, Symbol}; |
60c5eb7d | 19 | |
2b03887a FG |
20 | use crate::errors::ExprNotAllowedInContext; |
21 | ||
60c5eb7d XL |
22 | /// An expression that is not *always* legal in a const context. |
23 | #[derive(Clone, Copy)] | |
24 | enum NonConstExpr { | |
25 | Loop(hir::LoopSource), | |
26 | Match(hir::MatchSource), | |
27 | } | |
28 | ||
29 | impl NonConstExpr { | |
dfeec247 | 30 | fn name(self) -> String { |
60c5eb7d | 31 | match self { |
dfeec247 XL |
32 | Self::Loop(src) => format!("`{}`", src.name()), |
33 | Self::Match(src) => format!("`{}`", src.name()), | |
60c5eb7d XL |
34 | } |
35 | } | |
36 | ||
37 | fn required_feature_gates(self) -> Option<&'static [Symbol]> { | |
60c5eb7d | 38 | use hir::LoopSource::*; |
dfeec247 | 39 | use hir::MatchSource::*; |
60c5eb7d XL |
40 | |
41 | let gates: &[_] = match self { | |
94222f64 | 42 | Self::Match(AwaitDesugar) => { |
f035d41b | 43 | return None; |
ba9703b0 | 44 | } |
60c5eb7d | 45 | |
94222f64 XL |
46 | Self::Loop(ForLoop) | Self::Match(ForLoopDesugar) => &[sym::const_for], |
47 | ||
48 | Self::Match(TryDesugar) => &[sym::const_try], | |
fc512014 | 49 | |
f035d41b | 50 | // All other expressions are allowed. |
94222f64 | 51 | Self::Loop(Loop | While) | Self::Match(Normal) => &[], |
60c5eb7d XL |
52 | }; |
53 | ||
54 | Some(gates) | |
55 | } | |
56 | } | |
57 | ||
f035d41b | 58 | fn check_mod_const_bodies(tcx: TyCtxt<'_>, module_def_id: LocalDefId) { |
60c5eb7d | 59 | let mut vis = CheckConstVisitor::new(tcx); |
064997fb | 60 | tcx.hir().visit_item_likes_in_module(module_def_id, &mut vis); |
60c5eb7d XL |
61 | } |
62 | ||
f035d41b | 63 | pub(crate) fn provide(providers: &mut Providers) { |
dfeec247 | 64 | *providers = Providers { check_mod_const_bodies, ..*providers }; |
60c5eb7d XL |
65 | } |
66 | ||
67 | #[derive(Copy, Clone)] | |
68 | struct CheckConstVisitor<'tcx> { | |
69 | tcx: TyCtxt<'tcx>, | |
f9f354fc | 70 | const_kind: Option<hir::ConstContext>, |
f035d41b | 71 | def_id: Option<LocalDefId>, |
60c5eb7d XL |
72 | } |
73 | ||
74 | impl<'tcx> CheckConstVisitor<'tcx> { | |
75 | fn new(tcx: TyCtxt<'tcx>) -> Self { | |
f035d41b | 76 | CheckConstVisitor { tcx, const_kind: None, def_id: None } |
60c5eb7d XL |
77 | } |
78 | ||
79 | /// Emits an error when an unsupported expression is found in a const context. | |
80 | fn const_check_violated(&self, expr: NonConstExpr, span: Span) { | |
f035d41b XL |
81 | let Self { tcx, def_id, const_kind } = *self; |
82 | ||
83 | let features = tcx.features(); | |
60c5eb7d | 84 | let required_gates = expr.required_feature_gates(); |
f035d41b XL |
85 | |
86 | let is_feature_allowed = |feature_gate| { | |
87 | // All features require that the corresponding gate be enabled, | |
29967ef6 | 88 | // even if the function has `#[rustc_allow_const_fn_unstable(the_gate)]`. |
f035d41b XL |
89 | if !tcx.features().enabled(feature_gate) { |
90 | return false; | |
91 | } | |
92 | ||
93 | // If `def_id` is `None`, we don't need to consider stability attributes. | |
94 | let def_id = match def_id { | |
04454e1e | 95 | Some(x) => x, |
f035d41b XL |
96 | None => return true, |
97 | }; | |
98 | ||
3c0e092e XL |
99 | // If the function belongs to a trait, then it must enable the const_trait_impl |
100 | // feature to use that trait function (with a const default body). | |
064997fb | 101 | if tcx.trait_of_item(def_id.to_def_id()).is_some() { |
3c0e092e XL |
102 | return true; |
103 | } | |
104 | ||
f035d41b XL |
105 | // If this crate is not using stability attributes, or this function is not claiming to be a |
106 | // stable `const fn`, that is all that is required. | |
04454e1e FG |
107 | if !tcx.features().staged_api |
108 | || tcx.has_attr(def_id.to_def_id(), sym::rustc_const_unstable) | |
109 | { | |
f035d41b XL |
110 | return true; |
111 | } | |
112 | ||
113 | // However, we cannot allow stable `const fn`s to use unstable features without an explicit | |
29967ef6 | 114 | // opt-in via `rustc_allow_const_fn_unstable`. |
04454e1e FG |
115 | let attrs = tcx.hir().attrs(tcx.hir().local_def_id_to_hir_id(def_id)); |
116 | attr::rustc_allow_const_fn_unstable(&tcx.sess, attrs).any(|name| name == feature_gate) | |
f035d41b XL |
117 | }; |
118 | ||
60c5eb7d XL |
119 | match required_gates { |
120 | // Don't emit an error if the user has enabled the requisite feature gates. | |
f035d41b | 121 | Some(gates) if gates.iter().copied().all(is_feature_allowed) => return, |
60c5eb7d XL |
122 | |
123 | // `-Zunleash-the-miri-inside-of-you` only works for expressions that don't have a | |
124 | // corresponding feature gate. This encourages nightly users to use feature gates when | |
125 | // possible. | |
064997fb | 126 | None if tcx.sess.opts.unstable_opts.unleash_the_miri_inside_of_you => { |
f035d41b | 127 | tcx.sess.span_warn(span, "skipping const checks"); |
60c5eb7d XL |
128 | return; |
129 | } | |
130 | ||
131 | _ => {} | |
132 | } | |
133 | ||
f035d41b XL |
134 | let const_kind = |
135 | const_kind.expect("`const_check_violated` may only be called inside a const context"); | |
f9f354fc | 136 | |
60c5eb7d | 137 | let required_gates = required_gates.unwrap_or(&[]); |
dfeec247 XL |
138 | let missing_gates: Vec<_> = |
139 | required_gates.iter().copied().filter(|&g| !features.enabled(g)).collect(); | |
60c5eb7d XL |
140 | |
141 | match missing_gates.as_slice() { | |
5e7ed085 | 142 | [] => { |
2b03887a FG |
143 | tcx.sess.emit_err(ExprNotAllowedInContext { |
144 | span, | |
145 | expr: expr.name(), | |
146 | context: const_kind.keyword_name(), | |
147 | }); | |
5e7ed085 | 148 | } |
60c5eb7d | 149 | |
3c0e092e | 150 | [missing_primary, ref missing_secondary @ ..] => { |
2b03887a FG |
151 | let msg = |
152 | format!("{} is not allowed in a `{}`", expr.name(), const_kind.keyword_name()); | |
3c0e092e | 153 | let mut err = feature_err(&tcx.sess.parse_sess, *missing_primary, span, &msg); |
60c5eb7d XL |
154 | |
155 | // If multiple feature gates would be required to enable this expression, include | |
156 | // them as help messages. Don't emit a separate error for each missing feature gate. | |
157 | // | |
158 | // FIXME(ecstaticmorse): Maybe this could be incorporated into `feature_err`? This | |
159 | // is a pretty narrow case, however. | |
fc512014 | 160 | if tcx.sess.is_nightly_build() { |
60c5eb7d XL |
161 | for gate in missing_secondary { |
162 | let note = format!( | |
163 | "add `#![feature({})]` to the crate attributes to enable", | |
164 | gate, | |
165 | ); | |
166 | err.help(¬e); | |
167 | } | |
168 | } | |
169 | ||
170 | err.emit(); | |
171 | } | |
172 | } | |
173 | } | |
174 | ||
175 | /// Saves the parent `const_kind` before calling `f` and restores it afterwards. | |
f035d41b XL |
176 | fn recurse_into( |
177 | &mut self, | |
178 | kind: Option<hir::ConstContext>, | |
179 | def_id: Option<LocalDefId>, | |
180 | f: impl FnOnce(&mut Self), | |
181 | ) { | |
182 | let parent_def_id = self.def_id; | |
60c5eb7d | 183 | let parent_kind = self.const_kind; |
f035d41b | 184 | self.def_id = def_id; |
60c5eb7d XL |
185 | self.const_kind = kind; |
186 | f(self); | |
f035d41b | 187 | self.def_id = parent_def_id; |
60c5eb7d XL |
188 | self.const_kind = parent_kind; |
189 | } | |
190 | } | |
191 | ||
192 | impl<'tcx> Visitor<'tcx> for CheckConstVisitor<'tcx> { | |
5099ac24 | 193 | type NestedFilter = nested_filter::OnlyBodies; |
dfeec247 | 194 | |
5099ac24 FG |
195 | fn nested_visit_map(&mut self) -> Self::Map { |
196 | self.tcx.hir() | |
60c5eb7d XL |
197 | } |
198 | ||
199 | fn visit_anon_const(&mut self, anon: &'tcx hir::AnonConst) { | |
f9f354fc | 200 | let kind = Some(hir::ConstContext::Const); |
f035d41b | 201 | self.recurse_into(kind, None, |this| intravisit::walk_anon_const(this, anon)); |
60c5eb7d XL |
202 | } |
203 | ||
dfeec247 | 204 | fn visit_body(&mut self, body: &'tcx hir::Body<'tcx>) { |
f9f354fc XL |
205 | let owner = self.tcx.hir().body_owner_def_id(body.id()); |
206 | let kind = self.tcx.hir().body_const_context(owner); | |
f035d41b | 207 | self.recurse_into(kind, Some(owner), |this| intravisit::walk_body(this, body)); |
60c5eb7d XL |
208 | } |
209 | ||
dfeec247 | 210 | fn visit_expr(&mut self, e: &'tcx hir::Expr<'tcx>) { |
60c5eb7d XL |
211 | match &e.kind { |
212 | // Skip the following checks if we are not currently in a const context. | |
213 | _ if self.const_kind.is_none() => {} | |
214 | ||
5869c6ff | 215 | hir::ExprKind::Loop(_, _, source, _) => { |
60c5eb7d XL |
216 | self.const_check_violated(NonConstExpr::Loop(*source), e.span); |
217 | } | |
218 | ||
219 | hir::ExprKind::Match(_, _, source) => { | |
220 | let non_const_expr = match source { | |
221 | // These are handled by `ExprKind::Loop` above. | |
94222f64 | 222 | hir::MatchSource::ForLoopDesugar => None, |
60c5eb7d XL |
223 | |
224 | _ => Some(NonConstExpr::Match(*source)), | |
225 | }; | |
226 | ||
227 | if let Some(expr) = non_const_expr { | |
228 | self.const_check_violated(expr, e.span); | |
229 | } | |
230 | } | |
231 | ||
dfeec247 | 232 | _ => {} |
60c5eb7d XL |
233 | } |
234 | ||
dfeec247 | 235 | intravisit::walk_expr(self, e); |
60c5eb7d XL |
236 | } |
237 | } |