clippy_utils/
qualify_min_const_fn.rs

1// This code used to be a part of `rustc` but moved to Clippy as a result of
2// https://github.com/rust-lang/rust/issues/76618. Because of that, it contains unused code and some
3// of terminologies might not be relevant in the context of Clippy. Note that its behavior might
4// differ from the time of `rustc` even if the name stays the same.
5
6use 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    // impl trait is gone in MIR, so check the return type manually
51    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        // Cleanup blocks are ignored entirely by const eval, so we can too:
60        // https://github.com/rust-lang/rust/blob/1dea922ea6e74f99a0e97de5cdb8174e4dea0444/compiler/rustc_const_eval/src/transform/check_consts/check.rs#L382
61        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            // No constraints on lifetimes or constants, except potentially
77            // constants' types, but `walk` will get to them as well.
78            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                // We cannot allow this for now.
161                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                // Casting/coercing things to slices is fine.
169                Ok(())
170            } else {
171                // We just can't allow trait objects until we have figured out trait method calls.
172                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            // FIXME(dyn-star)
180            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        // binops are fine on integers
187        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        // just an assignment
238        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        // These are all NOPs
252        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                // FIXME: when analyzing a function with generic parameters, we may not have enough information to
369                // resolve to an instance. However, we could check if a host effect predicate can guarantee that
370                // this can be made a `const` call.
371                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                // HACK: This is to "unstabilize" the `transmute` intrinsic
388                // within const fns. `transmute` is allowed in all other const contexts.
389                // This won't really scale to more intrinsics or functions. Let's allow const
390                // transmutes in const fn before we add more hacks to this.
391                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
419/// Checks if the given `def_id` is a stable const fn, in respect to the given MSRV.
420pub 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                    // Checking MSRV is manually necessary because `rustc` has no such concept. This entire
433                    // function could be removed if `rustc` provided a MSRV-aware version of `is_stable_const_fn`.
434                    // as a part of an unimplemented MSRV check https://github.com/rust-lang/rust/issues/65262.
435
436                    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                    // Unstable const fn, check if the feature is enabled.
445                    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    // FIXME(const_trait_impl, fee1-dead) revert to const destruct once it works again
452    #[expect(unused)]
453    fn is_ty_const_destruct_unused<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>) -> bool {
454        // If this doesn't need drop at all, then don't select `[const] Destruct`.
455        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        // FIXME(const_trait_impl) constness
461        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}
clippy_utils/qualify_min_const_fn.rs

clippy_utils/
qualify_min_const_fn.rs
