Rename Constness variants to match BoundConstness

oli-obk · oli-obk · commit 1e2bd3f4b436 · 2025-11-24T17:43:44.000Z
diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -426,7 +426,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn generate_header_error(&self) -> hir::FnHeader {
         hir::FnHeader {
             safety: hir::Safety::Safe.into(),
-            constness: hir::Constness::NotConst,
+            constness: hir::Constness::Never,
             asyncness: hir::IsAsync::NotAsync,
             abi: ExternAbi::Rust,
         }
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
@@ -766,7 +766,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             fn_decl_span: self.lower_span(fn_decl_span),
             fn_arg_span: None,
             kind: hir::ClosureKind::Coroutine(coroutine_kind),
-            constness: hir::Constness::NotConst,
+            constness: hir::Constness::Never,
         }))
     }
 
@@ -1193,7 +1193,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             // knows that a `FnDecl` output type like `-> &str` actually means
             // "coroutine that returns &str", rather than directly returning a `&str`.
             kind: hir::ClosureKind::CoroutineClosure(coroutine_desugaring),
-            constness: hir::Constness::NotConst,
+            constness: hir::Constness::Never,
         });
         hir::ExprKind::Closure(c)
     }
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -1540,17 +1540,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
         let mut constness = self.lower_constness(h.constness);
         if let Some(&attr_span) = find_attr!(attrs, AttributeKind::Comptime(span) => span) {
-            match std::mem::replace(&mut constness, rustc_hir::Constness::Comptime) {
-                rustc_hir::Constness::Comptime => {
+            match std::mem::replace(&mut constness, rustc_hir::Constness::Always) {
+                rustc_hir::Constness::Always => {
                     unreachable!("lower_constness cannot produce comptime")
                 }
                 // A function can't be `const` and `comptime` at the same time
-                rustc_hir::Constness::Const => {
+                rustc_hir::Constness::Maybe => {
                     let Const::Yes(span) = h.constness else { unreachable!() };
                     self.dcx().emit_err(ConstComptimeFn { span, attr_span });
                 }
                 // Good
-                rustc_hir::Constness::NotConst => {}
+                rustc_hir::Constness::Never => {}
             }
         }
 
@@ -1621,8 +1621,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     pub(super) fn lower_constness(&mut self, c: Const) -> hir::Constness {
         match c {
-            Const::Yes(_) => hir::Constness::Const,
-            Const::No => hir::Constness::NotConst,
+            Const::Yes(_) => hir::Constness::Maybe,
+            Const::No => hir::Constness::Never,
         }
     }
 
diff --git a/compiler/rustc_const_eval/src/check_consts/ops.rs b/compiler/rustc_const_eval/src/check_consts/ops.rs
@@ -402,7 +402,7 @@ fn build_error_for_const_call<'tcx>(
                         err.help("const traits are not yet supported on stable Rust");
                     }
                 }
-            } else if ccx.tcx.constness(callee) != hir::Constness::Const {
+            } else if ccx.tcx.constness(callee) != hir::Constness::Maybe {
                 let name = ccx.tcx.item_name(callee);
                 err.span_note(
                     ccx.tcx.def_span(callee),
diff --git a/compiler/rustc_const_eval/src/const_eval/fn_queries.rs b/compiler/rustc_const_eval/src/const_eval/fn_queries.rs
@@ -11,12 +11,12 @@ fn parent_impl_or_trait_constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::C
         DefKind::Impl { of_trait: false } => tcx.constness(parent_id),
         DefKind::Trait => {
             if tcx.is_const_trait(parent_id.into()) {
-                hir::Constness::Const
+                hir::Constness::Maybe
             } else {
-                hir::Constness::NotConst
+                hir::Constness::Never
             }
         }
-        _ => hir::Constness::NotConst,
+        _ => hir::Constness::Never,
     }
 }
 
@@ -25,16 +25,16 @@ fn constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::Constness {
     let node = tcx.hir_node_by_def_id(def_id);
 
     match node {
-        hir::Node::Ctor(hir::VariantData::Tuple(..)) => hir::Constness::Const,
+        hir::Node::Ctor(hir::VariantData::Tuple(..)) => hir::Constness::Maybe,
         hir::Node::ForeignItem(item) if let hir::ForeignItemKind::Fn(..) = item.kind => {
             // Foreign functions cannot be evaluated at compile-time.
-            hir::Constness::NotConst
+            hir::Constness::Never
         }
         hir::Node::Expr(e) if let hir::ExprKind::Closure(c) = e.kind => c.constness,
         hir::Node::Item(i) if let hir::ItemKind::Impl(impl_) = i.kind => impl_.constness,
         _ => {
             if let Some(fn_kind) = node.fn_kind() {
-                if fn_kind.constness() != hir::Constness::NotConst {
+                if fn_kind.constness() != hir::Constness::Never {
                     return fn_kind.constness();
                 }
 
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -4228,18 +4228,18 @@ impl fmt::Display for Safety {
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Encodable, Decodable, HashStable_Generic)]
 #[derive(Default)]
 pub enum Constness {
-    Comptime,
-    Const,
+    Always,
+    Maybe,
     #[default]
-    NotConst,
+    Never,
 }
 
 impl fmt::Display for Constness {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match *self {
-            Self::Comptime => "comptime",
-            Self::Const => "const",
-            Self::NotConst => "non-const",
+            Self::Always => "comptime",
+            Self::Maybe => "const",
+            Self::Never => "non-const",
         })
     }
 }
@@ -4279,7 +4279,7 @@ impl FnHeader {
     }
 
     pub fn is_const(&self) -> bool {
-        matches!(self.constness, Constness::Const)
+        matches!(self.constness, Constness::Maybe)
     }
 
     pub fn is_unsafe(&self) -> bool {
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -98,7 +98,7 @@ impl<'a> FnKind<'a> {
     }
 
     pub fn constness(self) -> Constness {
-        self.header().map_or(Constness::NotConst, |header| header.constness)
+        self.header().map_or(Constness::Never, |header| header.constness)
     }
 
     pub fn asyncness(self) -> IsAsync {
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
@@ -1363,7 +1363,7 @@ fn check_impl_constness(
     constness: hir::Constness,
     hir_trait_ref: &hir::TraitRef<'_>,
 ) {
-    if let hir::Constness::NotConst = constness {
+    if let hir::Constness::Never = constness {
         return;
     }
 
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -703,7 +703,7 @@ impl<'a> State<'a> {
 
                 match of_trait {
                     None => {
-                        if let hir::Constness::Const = constness {
+                        if let hir::Constness::Maybe = constness {
                             self.word_nbsp("const");
                         }
                         impl_generics(self)
@@ -720,7 +720,7 @@ impl<'a> State<'a> {
 
                         impl_generics(self);
 
-                        if let hir::Constness::Const = constness {
+                        if let hir::Constness::Maybe = constness {
                             self.word_nbsp("const");
                         }
 
@@ -2529,7 +2529,7 @@ impl<'a> State<'a> {
             hir::FnHeader {
                 safety: safety.into(),
                 abi,
-                constness: hir::Constness::NotConst,
+                constness: hir::Constness::Never,
                 asyncness: hir::IsAsync::NotAsync,
             },
             name,
@@ -2569,9 +2569,9 @@ impl<'a> State<'a> {
 
     fn print_constness(&mut self, s: hir::Constness) {
         match s {
-            hir::Constness::NotConst => {}
-            hir::Constness::Const => self.word_nbsp("const"),
-            hir::Constness::Comptime => { /* printed as an attribute */ }
+            hir::Constness::Never => {}
+            hir::Constness::Maybe => self.word_nbsp("const"),
+            hir::Constness::Always => { /* printed as an attribute */ }
         }
     }
 
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
@@ -906,7 +906,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ) {
         let const_context = self.tcx.hir_body_const_context(self.body_id);
 
-        if let hir::Constness::Comptime = self.tcx.constness(callee_did) {
+        if let hir::Constness::Always = self.tcx.constness(callee_did) {
             match const_context {
                 Some(hir::ConstContext::Const { .. } | hir::ConstContext::Static(_)) => {}
                 Some(hir::ConstContext::ConstFn) | None => {
diff --git a/compiler/rustc_metadata/src/rmeta/table.rs b/compiler/rustc_metadata/src/rmeta/table.rs
@@ -37,8 +37,8 @@ impl IsDefault for ty::Asyncness {
 impl IsDefault for hir::Constness {
     fn is_default(&self) -> bool {
         match self {
-            hir::Constness::Const | hir::Constness::Comptime => false,
-            hir::Constness::NotConst => true,
+            hir::Constness::Maybe | hir::Constness::Always => false,
+            hir::Constness::Never => true,
         }
     }
 }
@@ -198,9 +198,9 @@ fixed_size_enum! {
 
 fixed_size_enum! {
     hir::Constness {
-        ( NotConst )
-        ( Const    )
-        ( Comptime )
+        ( Never )
+        ( Maybe    )
+        ( Always )
     }
 }
 
@@ -342,9 +342,9 @@ impl FixedSizeEncoding for hir::Constness {
     #[inline]
     fn from_bytes(b: &[u8; 1]) -> Self {
         match b[0] {
-            0 => hir::Constness::NotConst,
-            1 => hir::Constness::Const,
-            2 => hir::Constness::Comptime,
+            0 => hir::Constness::Never,
+            1 => hir::Constness::Maybe,
+            2 => hir::Constness::Always,
             _ => unreachable!(),
         }
     }
@@ -353,9 +353,9 @@ impl FixedSizeEncoding for hir::Constness {
     fn write_to_bytes(self, b: &mut [u8; 1]) {
         debug_assert!(!self.is_default());
         b[0] = match self {
-            hir::Constness::NotConst => 0,
-            hir::Constness::Const => 1,
-            hir::Constness::Comptime => 2,
+            hir::Constness::Never => 0,
+            hir::Constness::Maybe => 1,
+            hir::Constness::Always => 2,
         }
     }
 }
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
@@ -321,7 +321,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
             BodyOwnerKind::Fn if self.is_constructor(def_id) => return None,
             BodyOwnerKind::Fn | BodyOwnerKind::Closure if self.is_const_fn(def_id) => {
-                if self.constness(def_id) == rustc_hir::Constness::Comptime {
+                if self.constness(def_id) == rustc_hir::Constness::Always {
                     ConstContext::Const { allow_const_fn_promotion: false }
                 } else {
                     ConstContext::ConstFn
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
@@ -247,9 +247,9 @@ impl<'tcx> rustc_type_ir::inherent::AdtDef<TyCtxt<'tcx>> for AdtDef<'tcx> {
 
     fn destructor(self, tcx: TyCtxt<'tcx>) -> Option<AdtDestructorKind> {
         Some(match tcx.constness(self.destructor(tcx)?.did) {
-            hir::Constness::Comptime => todo!("FIXME(comptime)"),
-            hir::Constness::Const => AdtDestructorKind::Const,
-            hir::Constness::NotConst => AdtDestructorKind::NotConst,
+            hir::Constness::Always => todo!("FIXME(comptime)"),
+            hir::Constness::Maybe => AdtDestructorKind::Const,
+            hir::Constness::Never => AdtDestructorKind::NotConst,
         })
     }
 }
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -3463,7 +3463,7 @@ impl<'tcx> TyCtxt<'tcx> {
     /// Whether the trait impl is marked const. This does not consider stability or feature gates.
     pub fn is_const_trait_impl(self, def_id: DefId) -> bool {
         self.def_kind(def_id) == DefKind::Impl { of_trait: true }
-            && self.impl_trait_header(def_id).constness == hir::Constness::Const
+            && self.impl_trait_header(def_id).constness == hir::Constness::Maybe
     }
 
     pub fn is_sdylib_interface_build(self) -> bool {
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -2138,8 +2138,8 @@ impl<'tcx> TyCtxt<'tcx> {
             self.def_kind(def_id),
             DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::Closure
         ) && match self.constness(def_id) {
-            hir::Constness::Comptime | hir::Constness::Const => true,
-            hir::Constness::NotConst => false,
+            hir::Constness::Always | hir::Constness::Maybe => true,
+            hir::Constness::Never => false,
         }
     }
 
@@ -2154,12 +2154,12 @@ impl<'tcx> TyCtxt<'tcx> {
         match self.def_kind(def_id) {
             DefKind::Impl { of_trait: true } => {
                 let header = self.impl_trait_header(def_id);
-                header.constness == hir::Constness::Const
+                header.constness == hir::Constness::Maybe
                     && self.is_const_trait(header.trait_ref.skip_binder().def_id)
             }
-            DefKind::Impl { of_trait: false } => self.constness(def_id) == hir::Constness::Const,
+            DefKind::Impl { of_trait: false } => self.constness(def_id) == hir::Constness::Maybe,
             DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) => {
-                self.constness(def_id) == hir::Constness::Const
+                self.constness(def_id) == hir::Constness::Maybe
             }
             DefKind::TraitAlias | DefKind::Trait => self.is_const_trait(def_id),
             DefKind::AssocTy => {
@@ -2176,7 +2176,7 @@ impl<'tcx> TyCtxt<'tcx> {
                 let parent_def_id = self.parent(def_id);
                 match self.def_kind(parent_def_id) {
                     DefKind::Impl { of_trait: false } => {
-                        self.constness(def_id) == hir::Constness::Const
+                        self.constness(def_id) == hir::Constness::Maybe
                     }
                     DefKind::Impl { of_trait: true } | DefKind::Trait => {
                         self.is_conditionally_const(parent_def_id)
@@ -2223,7 +2223,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
     #[inline]
     pub fn is_const_trait(self, def_id: DefId) -> bool {
-        self.trait_def(def_id).constness == hir::Constness::Const
+        self.trait_def(def_id).constness == hir::Constness::Maybe
     }
 
     #[inline]
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
@@ -258,7 +258,7 @@ fn remap_mir_for_const_eval_select<'tcx>(
                 let fields = ty.tuple_fields();
                 let num_args = fields.len();
                 let func =
-                    if context == hir::Constness::Const { called_in_const } else { called_at_rt };
+                    if context == hir::Constness::Maybe { called_in_const } else { called_at_rt };
                 let (method, place): (fn(Place<'tcx>) -> Operand<'tcx>, Place<'tcx>) =
                     match tupled_args.node {
                         Operand::Constant(_) => {
@@ -429,7 +429,7 @@ fn mir_promoted(
 
     let const_qualifs = match tcx.def_kind(def) {
         DefKind::Fn | DefKind::AssocFn | DefKind::Closure
-            if tcx.constness(def) == hir::Constness::Const
+            if tcx.constness(def) == hir::Constness::Maybe
                 || tcx.is_const_default_method(def.to_def_id()) =>
         {
             tcx.mir_const_qualif(def)
@@ -503,7 +503,7 @@ fn inner_mir_for_ctfe(tcx: TyCtxt<'_>, def: LocalDefId) -> Body<'_> {
         None => bug!("`mir_for_ctfe` called on non-const {def:?}"),
     };
 
-    let mut body = remap_mir_for_const_eval_select(tcx, body, hir::Constness::Const);
+    let mut body = remap_mir_for_const_eval_select(tcx, body, hir::Constness::Maybe);
     pm::run_passes(tcx, &mut body, &[&ctfe_limit::CtfeLimit], None, pm::Optimizations::Allowed);
 
     body
@@ -797,7 +797,7 @@ fn inner_optimized_mir(tcx: TyCtxt<'_>, did: LocalDefId) -> Body<'_> {
     }
     debug!("about to call mir_drops_elaborated...");
     let body = tcx.mir_drops_elaborated_and_const_checked(did).steal();
-    let mut body = remap_mir_for_const_eval_select(tcx, body, hir::Constness::NotConst);
+    let mut body = remap_mir_for_const_eval_select(tcx, body, hir::Constness::Never);
 
     if body.tainted_by_errors.is_some() {
         return body;
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
@@ -658,7 +658,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                     }
 
                     if features.const_trait_impl()
-                        && let hir::Constness::Const = constness
+                        && let hir::Constness::Maybe = constness
                     {
                         let stable_or_implied_stable = match const_stab {
                             None => true,
@@ -702,7 +702,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                     }
                 }
 
-                if let hir::Constness::Const = constness
+                if let hir::Constness::Maybe = constness
                     && let Some(def_id) = of_trait.trait_ref.trait_def_id()
                 {
                     // FIXME(const_trait_impl): Improve the span here.
diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
diff --git a/src/tools/clippy/clippy_lints/src/derivable_impls.rs b/src/tools/clippy/clippy_lints/src/derivable_impls.rs
diff --git a/src/tools/clippy/clippy_lints/src/manual_float_methods.rs b/src/tools/clippy/clippy_lints/src/manual_float_methods.rs
diff --git a/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs b/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs

Original file line number	Diff line number	Diff line change
`@@ -426,7 +426,7 @@ impl<'hir> LoweringContext<'_, 'hir> {`
`426`	`426`	`fn generate_header_error(&self) -> hir::FnHeader {`
`427`	`427`	`hir::FnHeader {`
`428`	`428`	`safety: hir::Safety::Safe.into(),`
`429`		`- constness: hir::Constness::NotConst,`
	`429`	`+ constness: hir::Constness::Never,`
`430`	`430`	`asyncness: hir::IsAsync::NotAsync,`
`431`	`431`	`abi: ExternAbi::Rust,`
`432`	`432`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1540,17 +1540,17 @@ impl<'hir> LoweringContext<'_, 'hir> {`
`1540`	`1540`
`1541`	`1541`	`let mut constness = self.lower_constness(h.constness);`
`1542`	`1542`	`if let Some(&attr_span) = find_attr!(attrs, AttributeKind::Comptime(span) => span) {`
`1543`		`- match std::mem::replace(&mut constness, rustc_hir::Constness::Comptime) {`
`1544`		`- rustc_hir::Constness::Comptime => {`
	`1543`	`+ match std::mem::replace(&mut constness, rustc_hir::Constness::Always) {`
	`1544`	`+ rustc_hir::Constness::Always => {`
`1545`	`1545`	`unreachable!("lower_constness cannot produce comptime")`
`1546`	`1546`	`}`
`1547`	`1547`	// A function can't be `const` and `comptime` at the same time
`1548`		`- rustc_hir::Constness::Const => {`
	`1548`	`+ rustc_hir::Constness::Maybe => {`
`1549`	`1549`	`let Const::Yes(span) = h.constness else { unreachable!() };`
`1550`	`1550`	`self.dcx().emit_err(ConstComptimeFn { span, attr_span });`
`1551`	`1551`	`}`
`1552`	`1552`	`// Good`
`1553`		`- rustc_hir::Constness::NotConst => {}`
	`1553`	`+ rustc_hir::Constness::Never => {}`
`1554`	`1554`	`}`
`1555`	`1555`	`}`
`1556`	`1556`
`@@ -1621,8 +1621,8 @@ impl<'hir> LoweringContext<'_, 'hir> {`
`1621`	`1621`
`1622`	`1622`	`pub(super) fn lower_constness(&mut self, c: Const) -> hir::Constness {`
`1623`	`1623`	`match c {`
`1624`		`- Const::Yes(_) => hir::Constness::Const,`
`1625`		`- Const::No => hir::Constness::NotConst,`
	`1624`	`+ Const::Yes(_) => hir::Constness::Maybe,`
	`1625`	`+ Const::No => hir::Constness::Never,`
`1626`	`1626`	`}`
`1627`	`1627`	`}`
`1628`	`1628`
Original file line number	Diff line number	Diff line change
`@@ -402,7 +402,7 @@ fn build_error_for_const_call<'tcx>(`
`402`	`402`	`err.help("const traits are not yet supported on stable Rust");`
`403`	`403`	`}`
`404`	`404`	`}`
`405`		`- } else if ccx.tcx.constness(callee) != hir::Constness::Const {`
	`405`	`+ } else if ccx.tcx.constness(callee) != hir::Constness::Maybe {`
`406`	`406`	`let name = ccx.tcx.item_name(callee);`
`407`	`407`	`err.span_note(`
`408`	`408`	`ccx.tcx.def_span(callee),`
Original file line number	Diff line number	Diff line change
`@@ -11,12 +11,12 @@ fn parent_impl_or_trait_constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::C`
`11`	`11`	`DefKind::Impl { of_trait: false } => tcx.constness(parent_id),`
`12`	`12`	`DefKind::Trait => {`
`13`	`13`	`if tcx.is_const_trait(parent_id.into()) {`
`14`		`- hir::Constness::Const`
	`14`	`+ hir::Constness::Maybe`
`15`	`15`	`} else {`
`16`		`- hir::Constness::NotConst`
	`16`	`+ hir::Constness::Never`
`17`	`17`	`}`
`18`	`18`	`}`
`19`		`- _ => hir::Constness::NotConst,`
	`19`	`+ _ => hir::Constness::Never,`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`
`@@ -25,16 +25,16 @@ fn constness(tcx: TyCtxt<'_>, def_id: LocalDefId) -> hir::Constness {`
`25`	`25`	`let node = tcx.hir_node_by_def_id(def_id);`
`26`	`26`
`27`	`27`	`match node {`
`28`		`- hir::Node::Ctor(hir::VariantData::Tuple(..)) => hir::Constness::Const,`
	`28`	`+ hir::Node::Ctor(hir::VariantData::Tuple(..)) => hir::Constness::Maybe,`
`29`	`29`	`hir::Node::ForeignItem(item) if let hir::ForeignItemKind::Fn(..) = item.kind => {`
`30`	`30`	`// Foreign functions cannot be evaluated at compile-time.`
`31`		`- hir::Constness::NotConst`
	`31`	`+ hir::Constness::Never`
`32`	`32`	`}`
`33`	`33`	`hir::Node::Expr(e) if let hir::ExprKind::Closure(c) = e.kind => c.constness,`
`34`	`34`	`hir::Node::Item(i) if let hir::ItemKind::Impl(impl_) = i.kind => impl_.constness,`
`35`	`35`	`_ => {`
`36`	`36`	`if let Some(fn_kind) = node.fn_kind() {`
`37`		`- if fn_kind.constness() != hir::Constness::NotConst {`
	`37`	`+ if fn_kind.constness() != hir::Constness::Never {`
`38`	`38`	`return fn_kind.constness();`
`39`	`39`	`}`
`40`	`40`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ impl<'a> FnKind<'a> {`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`pub fn constness(self) -> Constness {`
`101`		`- self.header().map_or(Constness::NotConst, \|header\| header.constness)`
	`101`	`+ self.header().map_or(Constness::Never, \|header\| header.constness)`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`pub fn asyncness(self) -> IsAsync {`
Original file line number	Diff line number	Diff line change
`@@ -1363,7 +1363,7 @@ fn check_impl_constness(`
`1363`	`1363`	`constness: hir::Constness,`
`1364`	`1364`	`hir_trait_ref: &hir::TraitRef<'_>,`
`1365`	`1365`	`) {`
`1366`		`- if let hir::Constness::NotConst = constness {`
	`1366`	`+ if let hir::Constness::Never = constness {`
`1367`	`1367`	`return;`
`1368`	`1368`	`}`
`1369`	`1369`