1 use rustc_attr
as attr
;
3 use rustc_hir
::def_id
::{DefId, LocalDefId}
;
4 use rustc_middle
::hir
::map
::blocks
::FnLikeNode
;
5 use rustc_middle
::ty
::query
::Providers
;
6 use rustc_middle
::ty
::TyCtxt
;
7 use rustc_span
::symbol
::Symbol
;
8 use rustc_target
::spec
::abi
::Abi
;
10 /// Whether the `def_id` counts as const fn in your current crate, considering all active
12 pub fn is_const_fn(tcx
: TyCtxt
<'_
>, def_id
: DefId
) -> bool
{
13 tcx
.is_const_fn_raw(def_id
)
14 && match is_unstable_const_fn(tcx
, def_id
) {
15 Some(feature_name
) => {
16 // has a `rustc_const_unstable` attribute, check whether the user enabled the
17 // corresponding feature gate.
18 tcx
.features().declared_lib_features
.iter().any(|&(sym
, _
)| sym
== feature_name
)
20 // functions without const stability are either stable user written
21 // const fn or the user is using feature gates and we thus don't
27 /// Whether the `def_id` is an unstable const fn and what feature gate is necessary to enable it
28 pub fn is_unstable_const_fn(tcx
: TyCtxt
<'_
>, def_id
: DefId
) -> Option
<Symbol
> {
29 if tcx
.is_const_fn_raw(def_id
) {
30 let const_stab
= tcx
.lookup_const_stability(def_id
)?
;
31 if const_stab
.level
.is_unstable() { Some(const_stab.feature) }
else { None }
37 /// Returns `true` if this function must conform to `min_const_fn`
38 pub fn is_min_const_fn(tcx
: TyCtxt
<'_
>, def_id
: DefId
) -> bool
{
39 // Bail out if the signature doesn't contain `const`
40 if !tcx
.is_const_fn_raw(def_id
) {
44 if tcx
.features().staged_api
{
45 // In order for a libstd function to be considered min_const_fn
46 // it needs to be stable and have no `rustc_const_unstable` attribute.
47 match tcx
.lookup_const_stability(def_id
) {
48 // `rustc_const_unstable` functions don't need to conform.
49 Some(&attr
::ConstStability { ref level, .. }
) if level
.is_unstable() => false,
51 if let Some(stab
) = tcx
.lookup_stability(def_id
) {
52 if stab
.level
.is_stable() {
55 "stable const functions must have either `rustc_const_stable` or \
56 `rustc_const_unstable` attribute",
58 // While we errored above, because we don't know if we need to conform, we
59 // err on the "safe" side and require min_const_fn.
62 // Unstable functions need not conform to min_const_fn.
66 // Internal functions are forced to conform to min_const_fn.
67 // Annotate the internal function with a const stability attribute if
68 // you need to use unstable features.
69 // Note: this is an arbitrary choice that does not affect stability or const
70 // safety or anything, it just changes whether we need to annotate some
71 // internal functions with `rustc_const_stable` or with `rustc_const_unstable`
75 // Everything else needs to conform, because it would be callable from
76 // other `min_const_fn` functions.
80 // users enabling the `const_fn` feature gate can do what they want
81 !tcx
.features().const_fn
85 pub fn is_parent_const_impl_raw(tcx
: TyCtxt
<'_
>, hir_id
: hir
::HirId
) -> bool
{
86 let parent_id
= tcx
.hir().get_parent_did(hir_id
);
87 if !parent_id
.is_top_level_module() { is_const_impl_raw(tcx, parent_id) }
else { false }
90 /// Checks whether the function has a `const` modifier or, in case it is an intrinsic, whether
91 /// said intrinsic is on the whitelist for being const callable.
92 fn is_const_fn_raw(tcx
: TyCtxt
<'_
>, def_id
: DefId
) -> bool
{
94 tcx
.hir().as_local_hir_id(def_id
).expect("Non-local call to local provider is_const_fn");
96 let node
= tcx
.hir().get(hir_id
);
98 if let hir
::Node
::ForeignItem(hir
::ForeignItem { kind: hir::ForeignItemKind::Fn(..), .. }
) =
101 // Intrinsics use `rustc_const_{un,}stable` attributes to indicate constness. All other
102 // foreign items cannot be evaluated at compile-time.
103 if let Abi
::RustIntrinsic
| Abi
::PlatformIntrinsic
= tcx
.hir().get_foreign_abi(hir_id
) {
104 tcx
.lookup_const_stability(def_id
).is_some()
108 } else if let Some(fn_like
) = FnLikeNode
::from_node(node
) {
109 if fn_like
.constness() == hir
::Constness
::Const
{
113 // If the function itself is not annotated with `const`, it may still be a `const fn`
114 // if it resides in a const trait impl.
115 is_parent_const_impl_raw(tcx
, hir_id
)
116 } else if let hir
::Node
::Ctor(_
) = node
{
123 /// Checks whether the given item is an `impl` that has a `const` modifier.
124 fn is_const_impl_raw(tcx
: TyCtxt
<'_
>, def_id
: LocalDefId
) -> bool
{
125 let hir_id
= tcx
.hir().local_def_id_to_hir_id(def_id
);
126 let node
= tcx
.hir().get(hir_id
);
129 hir
::Node
::Item(hir
::Item
{
130 kind
: hir
::ItemKind
::Impl { constness: hir::Constness::Const, .. }
,
136 fn is_promotable_const_fn(tcx
: TyCtxt
<'_
>, def_id
: DefId
) -> bool
{
137 is_const_fn(tcx
, def_id
)
138 && match tcx
.lookup_const_stability(def_id
) {
140 if cfg
!(debug_assertions
) && stab
.promotable
{
141 let sig
= tcx
.fn_sig(def_id
);
144 hir
::Unsafety
::Normal
,
145 "don't mark const unsafe fns as promotable",
146 // https://github.com/rust-lang/rust/pull/53851#issuecomment-418760682
155 fn const_fn_is_allowed_fn_ptr(tcx
: TyCtxt
<'_
>, def_id
: DefId
) -> bool
{
156 is_const_fn(tcx
, def_id
)
157 && tcx
.lookup_const_stability(def_id
).map(|stab
| stab
.allow_const_fn_ptr
).unwrap_or(false)
160 pub fn provide(providers
: &mut Providers
<'_
>) {
161 *providers
= Providers
{
163 is_const_impl_raw
: |tcx
, def_id
| is_const_impl_raw(tcx
, def_id
.expect_local()),
164 is_promotable_const_fn
,
165 const_fn_is_allowed_fn_ptr
,