1use crate::msrvs::{self, Msrv};
7use hir::LangItem;
8use rustc_attr_data_structures::{RustcVersion, StableSince};
9use rustc_const_eval::check_consts::ConstCx;
10use rustc_hir as hir;
11use rustc_hir::def_id::DefId;
12use rustc_infer::infer::TyCtxtInferExt;
13use rustc_infer::traits::Obligation;
14use rustc_lint::LateContext;
15use rustc_middle::mir::{
16 Body, CastKind, NonDivergingIntrinsic, NullOp, Operand, Place, ProjectionElem, Rvalue, Statement, StatementKind,
17 Terminator, TerminatorKind,
18};
19use rustc_middle::traits::{BuiltinImplSource, ImplSource, ObligationCause};
20use rustc_middle::ty::adjustment::PointerCoercion;
21use rustc_middle::ty::{self, GenericArgKind, Instance, TraitRef, Ty, TyCtxt};
22use rustc_span::Span;
23use rustc_span::symbol::sym;
24use rustc_trait_selection::traits::{ObligationCtxt, SelectionContext};
25use std::borrow::Cow;
26
27type McfResult = Result<(), (Span, Cow<'static, str>)>;
28
29pub fn is_min_const_fn<'tcx>(cx: &LateContext<'tcx>, body: &Body<'tcx>, msrv: Msrv) -> McfResult {
30 let def_id = body.source.def_id();
31
32 for local in &body.local_decls {
33 check_ty(cx, local.ty, local.source_info.span, msrv)?;
34 }
35 if !msrv.meets(cx, msrvs::CONST_FN_TRAIT_BOUND)
36 && let Some(sized_did) = cx.tcx.lang_items().sized_trait()
37 && let Some(meta_sized_did) = cx.tcx.lang_items().meta_sized_trait()
38 && cx.tcx.param_env(def_id).caller_bounds().iter().any(|bound| {
39 bound.as_trait_clause().is_some_and(|clause| {
40 let did = clause.def_id();
41 did != sized_did && did != meta_sized_did
42 })
43 })
44 {
45 return Err((
46 body.span,
47 "non-`Sized` trait clause before `const_fn_trait_bound` is stabilized".into(),
48 ));
49 }
50 check_ty(
52 cx,
53 cx.tcx.fn_sig(def_id).instantiate_identity().output().skip_binder(),
54 body.local_decls.iter().next().unwrap().source_info.span,
55 msrv,
56 )?;
57
58 for bb in &*body.basic_blocks {
59 if !bb.is_cleanup {
62 check_terminator(cx, body, bb.terminator(), msrv)?;
63 for stmt in &bb.statements {
64 check_statement(cx, body, def_id, stmt, msrv)?;
65 }
66 }
67 }
68 Ok(())
69}
70
71fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, msrv: Msrv) -> McfResult {
72 for arg in ty.walk() {
73 let ty = match arg.kind() {
74 GenericArgKind::Type(ty) => ty,
75
76 GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => continue,
79 };
80
81 match ty.kind() {
82 ty::Ref(_, _, hir::Mutability::Mut) if !msrv.meets(cx, msrvs::CONST_MUT_REFS) => {
83 return Err((span, "mutable references in const fn are unstable".into()));
84 },
85 ty::Alias(ty::Opaque, ..) => return Err((span, "`impl Trait` in const fn is unstable".into())),
86 ty::FnPtr(..) => {
87 return Err((span, "function pointers in const fn are unstable".into()));
88 },
89 ty::Dynamic(preds, _, _) => {
90 for pred in *preds {
91 match pred.skip_binder() {
92 ty::ExistentialPredicate::AutoTrait(_) | ty::ExistentialPredicate::Projection(_) => {
93 return Err((
94 span,
95 "trait bounds other than `Sized` \
96 on const fn parameters are unstable"
97 .into(),
98 ));
99 },
100 ty::ExistentialPredicate::Trait(trait_ref) => {
101 if Some(trait_ref.def_id) != cx.tcx.lang_items().sized_trait() {
102 return Err((
103 span,
104 "trait bounds other than `Sized` \
105 on const fn parameters are unstable"
106 .into(),
107 ));
108 }
109 },
110 }
111 }
112 },
113 _ => {},
114 }
115 }
116 Ok(())
117}
118
119fn check_rvalue<'tcx>(
120 cx: &LateContext<'tcx>,
121 body: &Body<'tcx>,
122 def_id: DefId,
123 rvalue: &Rvalue<'tcx>,
124 span: Span,
125 msrv: Msrv,
126) -> McfResult {
127 match rvalue {
128 Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
129 Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
130 check_place(cx, *place, span, body, msrv)
131 },
132 Rvalue::CopyForDeref(place) => check_place(cx, *place, span, body, msrv),
133 Rvalue::Repeat(operand, _)
134 | Rvalue::Use(operand)
135 | Rvalue::WrapUnsafeBinder(operand, _)
136 | Rvalue::Cast(
137 CastKind::PointerWithExposedProvenance
138 | CastKind::IntToInt
139 | CastKind::FloatToInt
140 | CastKind::IntToFloat
141 | CastKind::FloatToFloat
142 | CastKind::FnPtrToPtr
143 | CastKind::PtrToPtr
144 | CastKind::PointerCoercion(PointerCoercion::MutToConstPointer | PointerCoercion::ArrayToPointer, _),
145 operand,
146 _,
147 ) => check_operand(cx, operand, span, body, msrv),
148 Rvalue::Cast(
149 CastKind::PointerCoercion(
150 PointerCoercion::UnsafeFnPointer
151 | PointerCoercion::ClosureFnPointer(_)
152 | PointerCoercion::ReifyFnPointer,
153 _,
154 ),
155 _,
156 _,
157 ) => Err((span, "function pointer casts are not allowed in const fn".into())),
158 Rvalue::Cast(CastKind::PointerCoercion(PointerCoercion::Unsize, _), op, cast_ty) => {
159 let Some(pointee_ty) = cast_ty.builtin_deref(true) else {
160 return Err((span, "unsizing casts are only allowed for references right now".into()));
162 };
163 let unsized_ty = cx
164 .tcx
165 .struct_tail_for_codegen(pointee_ty, ty::TypingEnv::post_analysis(cx.tcx, def_id));
166 if let ty::Slice(_) | ty::Str = unsized_ty.kind() {
167 check_operand(cx, op, span, body, msrv)?;
168 Ok(())
170 } else {
171 Err((span, "unsizing casts are not allowed in const fn".into()))
173 }
174 },
175 Rvalue::Cast(CastKind::PointerExposeProvenance, _, _) => {
176 Err((span, "casting pointers to ints is unstable in const fn".into()))
177 },
178 Rvalue::Cast(CastKind::PointerCoercion(PointerCoercion::DynStar, _), _, _) => {
179 unimplemented!()
181 },
182 Rvalue::Cast(CastKind::Transmute, _, _) => Err((
183 span,
184 "transmute can attempt to turn pointers into integers, so is unstable in const fn".into(),
185 )),
186 Rvalue::BinaryOp(_, box (lhs, rhs)) => {
188 check_operand(cx, lhs, span, body, msrv)?;
189 check_operand(cx, rhs, span, body, msrv)?;
190 let ty = lhs.ty(body, cx.tcx);
191 if ty.is_integral() || ty.is_bool() || ty.is_char() {
192 Ok(())
193 } else {
194 Err((
195 span,
196 "only int, `bool` and `char` operations are stable in const fn".into(),
197 ))
198 }
199 },
200 Rvalue::NullaryOp(
201 NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(_) | NullOp::UbChecks | NullOp::ContractChecks,
202 _,
203 )
204 | Rvalue::ShallowInitBox(_, _) => Ok(()),
205 Rvalue::UnaryOp(_, operand) => {
206 let ty = operand.ty(body, cx.tcx);
207 if ty.is_integral() || ty.is_bool() {
208 check_operand(cx, operand, span, body, msrv)
209 } else {
210 Err((span, "only int and `bool` operations are stable in const fn".into()))
211 }
212 },
213 Rvalue::Aggregate(_, operands) => {
214 for operand in operands {
215 check_operand(cx, operand, span, body, msrv)?;
216 }
217 Ok(())
218 },
219 }
220}
221
222fn check_statement<'tcx>(
223 cx: &LateContext<'tcx>,
224 body: &Body<'tcx>,
225 def_id: DefId,
226 statement: &Statement<'tcx>,
227 msrv: Msrv,
228) -> McfResult {
229 let span = statement.source_info.span;
230 match &statement.kind {
231 StatementKind::Assign(box (place, rval)) => {
232 check_place(cx, *place, span, body, msrv)?;
233 check_rvalue(cx, body, def_id, rval, span, msrv)
234 },
235
236 StatementKind::FakeRead(box (_, place)) => check_place(cx, *place, span, body, msrv),
237 StatementKind::SetDiscriminant { place, .. } | StatementKind::Deinit(place) => {
239 check_place(cx, **place, span, body, msrv)
240 },
241
242 StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(op)) => check_operand(cx, op, span, body, msrv),
243
244 StatementKind::Intrinsic(box NonDivergingIntrinsic::CopyNonOverlapping(
245 rustc_middle::mir::CopyNonOverlapping { dst, src, count },
246 )) => {
247 check_operand(cx, dst, span, body, msrv)?;
248 check_operand(cx, src, span, body, msrv)?;
249 check_operand(cx, count, span, body, msrv)
250 },
251 StatementKind::StorageLive(_)
253 | StatementKind::StorageDead(_)
254 | StatementKind::Retag { .. }
255 | StatementKind::AscribeUserType(..)
256 | StatementKind::PlaceMention(..)
257 | StatementKind::Coverage(..)
258 | StatementKind::ConstEvalCounter
259 | StatementKind::BackwardIncompatibleDropHint { .. }
260 | StatementKind::Nop => Ok(()),
261 }
262}
263
264fn check_operand<'tcx>(
265 cx: &LateContext<'tcx>,
266 operand: &Operand<'tcx>,
267 span: Span,
268 body: &Body<'tcx>,
269 msrv: Msrv,
270) -> McfResult {
271 match operand {
272 Operand::Move(place) => {
273 if !place.projection.as_ref().is_empty()
274 && !is_ty_const_destruct(cx.tcx, place.ty(&body.local_decls, cx.tcx).ty, body)
275 {
276 return Err((
277 span,
278 "cannot drop locals with a non constant destructor in const fn".into(),
279 ));
280 }
281
282 check_place(cx, *place, span, body, msrv)
283 },
284 Operand::Copy(place) => check_place(cx, *place, span, body, msrv),
285 Operand::Constant(c) => match c.check_static_ptr(cx.tcx) {
286 Some(_) => Err((span, "cannot access `static` items in const fn".into())),
287 None => Ok(()),
288 },
289 }
290}
291
292fn check_place<'tcx>(
293 cx: &LateContext<'tcx>,
294 place: Place<'tcx>,
295 span: Span,
296 body: &Body<'tcx>,
297 msrv: Msrv,
298) -> McfResult {
299 for (base, elem) in place.as_ref().iter_projections() {
300 match elem {
301 ProjectionElem::Field(..) => {
302 if base.ty(body, cx.tcx).ty.is_union() && !msrv.meets(cx, msrvs::CONST_FN_UNION) {
303 return Err((span, "accessing union fields is unstable".into()));
304 }
305 },
306 ProjectionElem::Deref => match base.ty(body, cx.tcx).ty.kind() {
307 ty::RawPtr(_, hir::Mutability::Mut) => {
308 return Err((span, "dereferencing raw mut pointer in const fn is unstable".into()));
309 },
310 ty::RawPtr(_, hir::Mutability::Not) if !msrv.meets(cx, msrvs::CONST_RAW_PTR_DEREF) => {
311 return Err((span, "dereferencing raw const pointer in const fn is unstable".into()));
312 },
313 _ => (),
314 },
315 ProjectionElem::ConstantIndex { .. }
316 | ProjectionElem::OpaqueCast(..)
317 | ProjectionElem::Downcast(..)
318 | ProjectionElem::Subslice { .. }
319 | ProjectionElem::Subtype(_)
320 | ProjectionElem::Index(_)
321 | ProjectionElem::UnwrapUnsafeBinder(_) => {},
322 }
323 }
324
325 Ok(())
326}
327
328fn check_terminator<'tcx>(
329 cx: &LateContext<'tcx>,
330 body: &Body<'tcx>,
331 terminator: &Terminator<'tcx>,
332 msrv: Msrv,
333) -> McfResult {
334 let span = terminator.source_info.span;
335 match &terminator.kind {
336 TerminatorKind::FalseEdge { .. }
337 | TerminatorKind::FalseUnwind { .. }
338 | TerminatorKind::Goto { .. }
339 | TerminatorKind::Return
340 | TerminatorKind::UnwindResume
341 | TerminatorKind::UnwindTerminate(_)
342 | TerminatorKind::Unreachable => Ok(()),
343 TerminatorKind::Drop { place, .. } => {
344 if !is_ty_const_destruct(cx.tcx, place.ty(&body.local_decls, cx.tcx).ty, body) {
345 return Err((
346 span,
347 "cannot drop locals with a non constant destructor in const fn".into(),
348 ));
349 }
350 Ok(())
351 },
352 TerminatorKind::SwitchInt { discr, targets: _ } => check_operand(cx, discr, span, body, msrv),
353 TerminatorKind::CoroutineDrop | TerminatorKind::Yield { .. } => {
354 Err((span, "const fn coroutines are unstable".into()))
355 },
356 TerminatorKind::Call {
357 func,
358 args,
359 call_source: _,
360 destination: _,
361 target: _,
362 unwind: _,
363 fn_span: _,
364 }
365 | TerminatorKind::TailCall { func, args, fn_span: _ } => {
366 let fn_ty = func.ty(body, cx.tcx);
367 if let ty::FnDef(fn_def_id, fn_substs) = fn_ty.kind() {
368 let fn_def_id = match Instance::try_resolve(cx.tcx, cx.typing_env(), *fn_def_id, fn_substs) {
372 Ok(Some(fn_inst)) => fn_inst.def_id(),
373 Ok(None) => return Err((span, format!("cannot resolve instance for {func:?}").into())),
374 Err(_) => return Err((span, format!("error during instance resolution of {func:?}").into())),
375 };
376 if !is_stable_const_fn(cx, fn_def_id, msrv) {
377 return Err((
378 span,
379 format!(
380 "can only call other `const fn` within a `const fn`, \
381 but `{func:?}` is not stable as `const fn`",
382 )
383 .into(),
384 ));
385 }
386
387 if cx.tcx.is_intrinsic(fn_def_id, sym::transmute) {
392 return Err((
393 span,
394 "can only call `transmute` from const items, not `const fn`".into(),
395 ));
396 }
397
398 check_operand(cx, func, span, body, msrv)?;
399
400 for arg in args {
401 check_operand(cx, &arg.node, span, body, msrv)?;
402 }
403 Ok(())
404 } else {
405 Err((span, "can only call other const fns within const fn".into()))
406 }
407 },
408 TerminatorKind::Assert {
409 cond,
410 expected: _,
411 msg: _,
412 target: _,
413 unwind: _,
414 } => check_operand(cx, cond, span, body, msrv),
415 TerminatorKind::InlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
416 }
417}
418
419pub fn is_stable_const_fn(cx: &LateContext<'_>, def_id: DefId, msrv: Msrv) -> bool {
421 cx.tcx.is_const_fn(def_id)
422 && cx
423 .tcx
424 .lookup_const_stability(def_id)
425 .or_else(|| {
426 cx.tcx
427 .trait_of_item(def_id)
428 .and_then(|trait_def_id| cx.tcx.lookup_const_stability(trait_def_id))
429 })
430 .is_none_or(|const_stab| {
431 if let rustc_attr_data_structures::StabilityLevel::Stable { since, .. } = const_stab.level {
432 let const_stab_rust_version = match since {
437 StableSince::Version(version) => version,
438 StableSince::Current => RustcVersion::CURRENT,
439 StableSince::Err => return false,
440 };
441
442 msrv.meets(cx, const_stab_rust_version)
443 } else {
444 cx.tcx.features().enabled(const_stab.feature) && msrv.current(cx).is_none()
446 }
447 })
448}
449
450fn is_ty_const_destruct<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>) -> bool {
451 #[expect(unused)]
453 fn is_ty_const_destruct_unused<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>) -> bool {
454 if !ty.needs_drop(tcx, body.typing_env(tcx)) {
456 return false;
457 }
458
459 let (infcx, param_env) = tcx.infer_ctxt().build_with_typing_env(body.typing_env(tcx));
460 let obligation = Obligation::new(
462 tcx,
463 ObligationCause::dummy_with_span(body.span),
464 param_env,
465 TraitRef::new(tcx, tcx.require_lang_item(LangItem::Destruct, body.span), [ty]),
466 );
467
468 let mut selcx = SelectionContext::new(&infcx);
469 let Some(impl_src) = selcx.select(&obligation).ok().flatten() else {
470 return false;
471 };
472
473 if !matches!(
474 impl_src,
475 ImplSource::Builtin(BuiltinImplSource::Misc, _) | ImplSource::Param(_)
476 ) {
477 return false;
478 }
479
480 let ocx = ObligationCtxt::new(&infcx);
481 ocx.register_obligations(impl_src.nested_obligations());
482 ocx.select_all_or_error().is_empty()
483 }
484
485 !ty.needs_drop(tcx, ConstCx::new(tcx, body).typing_env)
486}