From 802f3a78a6eea323617964a168a612d1b0826bd6 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 29 Oct 2024 23:42:59 +0000
Subject: [PATCH] Merge HostPolarity and BoundConstness
---
compiler/rustc_hir_analysis/src/bounds.rs | 4 +-
.../src/check/compare_impl_item.rs | 10 ++--
.../rustc_hir_analysis/src/check/wfcheck.rs | 2 +-
.../src/collect/predicates_of.rs | 12 ++--
.../src/hir_ty_lowering/mod.rs | 9 ++-
compiler/rustc_hir_typeck/src/callee.rs | 4 +-
compiler/rustc_middle/src/ty/context.rs | 6 +-
compiler/rustc_middle/src/ty/flags.rs | 2 +-
compiler/rustc_middle/src/ty/print/pretty.rs | 8 +--
.../src/solve/effect_goals.rs | 11 ++--
compiler/rustc_privacy/src/lib.rs | 2 +-
.../traits/fulfillment_errors.rs | 13 ++---
.../src/traits/effects.rs | 5 +-
compiler/rustc_ty_utils/src/ty.rs | 2 +-
compiler/rustc_type_ir/src/elaborate.rs | 2 +-
compiler/rustc_type_ir/src/predicate.rs | 55 ++++++-------------
16 files changed, 66 insertions(+), 81 deletions(-)
diff --git a/compiler/rustc_hir_analysis/src/bounds.rs b/compiler/rustc_hir_analysis/src/bounds.rs
index 09ddc6ca9de1d..9b02651a8bdf5 100644
--- a/compiler/rustc_hir_analysis/src/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/bounds.rs
@@ -84,11 +84,11 @@ impl<'tcx> Bounds<'tcx> {
&mut self,
tcx: TyCtxt<'tcx>,
bound_trait_ref: ty::PolyTraitRef<'tcx>,
- host: ty::HostPolarity,
+ constness: ty::BoundConstness,
span: Span,
) {
if tcx.is_const_trait(bound_trait_ref.def_id()) {
- self.clauses.push((bound_trait_ref.to_host_effect_clause(tcx, host), span));
+ self.clauses.push((bound_trait_ref.to_host_effect_clause(tcx, constness), span));
} else {
tcx.dcx().span_delayed_bug(span, "tried to lower {host:?} bound for non-const trait");
}
diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
index db2c44fd29df4..796999c65243d 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
@@ -218,7 +218,7 @@ fn compare_method_predicate_entailment<'tcx>(
tcx.const_conditions(trait_m.def_id).instantiate_own(tcx, trait_to_impl_args),
)
.map(|(trait_ref, _)| {
- trait_ref.to_host_effect_clause(tcx, ty::HostPolarity::Maybe)
+ trait_ref.to_host_effect_clause(tcx, ty::BoundConstness::Maybe)
}),
);
}
@@ -272,7 +272,7 @@ fn compare_method_predicate_entailment<'tcx>(
tcx,
cause,
param_env,
- const_condition.to_host_effect_clause(tcx, ty::HostPolarity::Maybe),
+ const_condition.to_host_effect_clause(tcx, ty::BoundConstness::Maybe),
));
}
}
@@ -1942,7 +1942,7 @@ fn compare_type_predicate_entailment<'tcx>(
tcx.const_conditions(trait_ty.def_id).instantiate_own(tcx, trait_to_impl_args),
)
.map(|(trait_ref, _)| {
- trait_ref.to_host_effect_clause(tcx, ty::HostPolarity::Maybe)
+ trait_ref.to_host_effect_clause(tcx, ty::BoundConstness::Maybe)
}),
);
}
@@ -1985,7 +1985,7 @@ fn compare_type_predicate_entailment<'tcx>(
tcx,
cause,
param_env,
- const_condition.to_host_effect_clause(tcx, ty::HostPolarity::Maybe),
+ const_condition.to_host_effect_clause(tcx, ty::BoundConstness::Maybe),
));
}
}
@@ -2091,7 +2091,7 @@ pub(super) fn check_type_bounds<'tcx>(
tcx,
mk_cause(span),
param_env,
- c.to_host_effect_clause(tcx, ty::HostPolarity::Maybe),
+ c.to_host_effect_clause(tcx, ty::BoundConstness::Maybe),
)
}),
);
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index 12ed7b89f68be..b9e18d784ce94 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1389,7 +1389,7 @@ fn check_impl<'tcx>(
ObligationCauseCode::WellFormed(None),
),
wfcx.param_env,
- bound.to_host_effect_clause(tcx, ty::HostPolarity::Maybe),
+ bound.to_host_effect_clause(tcx, ty::BoundConstness::Maybe),
))
}
}
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index 644ff0c667c6b..2a0751ba09100 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -716,7 +716,7 @@ pub(super) fn assert_only_contains_predicates_from<'tcx>(
match clause.kind().skip_binder() {
ty::ClauseKind::HostEffect(ty::HostEffectPredicate {
trait_ref: _,
- host: ty::HostPolarity::Maybe,
+ constness: ty::BoundConstness::Maybe,
}) => {}
_ => {
bug!(
@@ -732,8 +732,8 @@ pub(super) fn assert_only_contains_predicates_from<'tcx>(
match clause.kind().skip_binder() {
ty::ClauseKind::HostEffect(pred) => {
assert_eq!(
- pred.host,
- ty::HostPolarity::Maybe,
+ pred.constness,
+ ty::BoundConstness::Maybe,
"expected `~const` predicate when computing `{filter:?}` \
implied bounds: {clause:?}",
);
@@ -943,7 +943,7 @@ pub(super) fn const_conditions<'tcx>(
bounds.push_const_bound(
tcx,
ty::Binder::dummy(ty::TraitRef::identity(tcx, def_id.to_def_id())),
- ty::HostPolarity::Maybe,
+ ty::BoundConstness::Maybe,
DUMMY_SP,
);
@@ -963,7 +963,7 @@ pub(super) fn const_conditions<'tcx>(
clause.kind().map_bound(|clause| match clause {
ty::ClauseKind::HostEffect(ty::HostEffectPredicate {
trait_ref,
- host: ty::HostPolarity::Maybe,
+ constness: ty::BoundConstness::Maybe,
}) => trait_ref,
_ => bug!("converted {clause:?}"),
}),
@@ -1001,7 +1001,7 @@ pub(super) fn implied_const_bounds<'tcx>(
clause.kind().map_bound(|clause| match clause {
ty::ClauseKind::HostEffect(ty::HostEffectPredicate {
trait_ref,
- host: ty::HostPolarity::Maybe,
+ constness: ty::BoundConstness::Maybe,
}) => trait_ref,
_ => bug!("converted {clause:?}"),
}),
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 2d0c3ec28c372..74bd0174cf567 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -713,7 +713,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
bounds.push_const_bound(
tcx,
poly_trait_ref,
- ty::HostPolarity::Const,
+ ty::BoundConstness::Const,
span,
);
}
@@ -736,7 +736,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
PredicateFilter::ConstIfConst | PredicateFilter::SelfConstIfConst => match constness {
hir::BoundConstness::Maybe(span) => {
if polarity == ty::PredicatePolarity::Positive {
- bounds.push_const_bound(tcx, poly_trait_ref, ty::HostPolarity::Maybe, span);
+ bounds.push_const_bound(
+ tcx,
+ poly_trait_ref,
+ ty::BoundConstness::Maybe,
+ span,
+ );
}
}
hir::BoundConstness::Always(_) | hir::BoundConstness::Never => {}
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index 9cf1ea3fcb881..93d50bf3d7b3b 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -853,9 +853,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let host = match self.tcx.hir().body_const_context(self.body_id) {
Some(hir::ConstContext::Const { .. } | hir::ConstContext::Static(_)) => {
- ty::HostPolarity::Const
+ ty::BoundConstness::Const
}
- Some(hir::ConstContext::ConstFn) => ty::HostPolarity::Maybe,
+ Some(hir::ConstContext::ConstFn) => ty::BoundConstness::Maybe,
None => return,
};
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 5cbbc80ebfbb6..a3c0908ce5b24 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -76,8 +76,8 @@ use crate::traits::solve::{
};
use crate::ty::predicate::ExistentialPredicateStableCmpExt as _;
use crate::ty::{
- self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Clauses, Const, GenericArg, GenericArgs,
- GenericArgsRef, GenericParamDefKind, HostPolarity, ImplPolarity, List, ListWithCachedTypeInfo,
+ self, AdtDef, AdtDefData, AdtKind, Binder, BoundConstness, Clause, Clauses, Const, GenericArg,
+ GenericArgs, GenericArgsRef, GenericParamDefKind, ImplPolarity, List, ListWithCachedTypeInfo,
ParamConst, ParamTy, Pattern, PatternKind, PolyExistentialPredicate, PolyFnSig, Predicate,
PredicateKind, PredicatePolarity, Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty,
TyKind, TyVid, Visibility,
@@ -2205,7 +2205,7 @@ macro_rules! nop_slice_lift {
nop_slice_lift! {ty::ValTree<'a> => ty::ValTree<'tcx>}
TrivialLiftImpls! {
- ImplPolarity, PredicatePolarity, Promoted, HostPolarity,
+ ImplPolarity, PredicatePolarity, Promoted, BoundConstness,
}
macro_rules! sty_debug_print {
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
index 704a197aa49d0..04d03187541ce 100644
--- a/compiler/rustc_middle/src/ty/flags.rs
+++ b/compiler/rustc_middle/src/ty/flags.rs
@@ -267,7 +267,7 @@ impl FlagComputation {
}
ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(ty::HostEffectPredicate {
trait_ref,
- host: _,
+ constness: _,
})) => {
self.add_args(trait_ref.args);
}
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 0248aad53e248..2480cee3dc4b6 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1959,7 +1959,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
ty::BoundConstness::Const => {
p!("const ");
}
- ty::BoundConstness::ConstIfConst => {
+ ty::BoundConstness::Maybe => {
p!("~const ");
}
}
@@ -3076,9 +3076,9 @@ define_print! {
}
ty::HostEffectPredicate<'tcx> {
- let constness = match self.host {
- ty::HostPolarity::Const => { "const" }
- ty::HostPolarity::Maybe => { "~const" }
+ let constness = match self.constness {
+ ty::BoundConstness::Const => { "const" }
+ ty::BoundConstness::Maybe => { "~const" }
};
p!(print(self.trait_ref.self_ty()), ": {constness} ");
p!(print(self.trait_ref.print_trait_sugared()))
diff --git a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
index 8d57ad8f2551b..5bfc156ed94fe 100644
--- a/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/effect_goals.rs
@@ -44,7 +44,7 @@ where
) -> Result<Candidate<I>, NoSolution> {
if let Some(host_clause) = assumption.as_host_effect_clause() {
if host_clause.def_id() == goal.predicate.def_id()
- && host_clause.host().satisfies(goal.predicate.host)
+ && host_clause.constness().satisfies(goal.predicate.constness)
{
if !DeepRejectCtxt::relate_rigid_rigid(ecx.cx()).args_may_unify(
goal.predicate.trait_ref.args,
@@ -91,7 +91,7 @@ where
cx,
cx.implied_const_bounds(alias_ty.def_id)
.iter_instantiated(cx, alias_ty.args)
- .map(|trait_ref| trait_ref.to_host_effect_clause(cx, goal.predicate.host)),
+ .map(|trait_ref| trait_ref.to_host_effect_clause(cx, goal.predicate.constness)),
) {
candidates.extend(Self::probe_and_match_goal_against_assumption(
ecx,
@@ -107,7 +107,7 @@ where
.map(|trait_ref| {
goal.with(
cx,
- trait_ref.to_host_effect_clause(cx, goal.predicate.host),
+ trait_ref.to_host_effect_clause(cx, goal.predicate.constness),
)
}),
);
@@ -163,7 +163,10 @@ where
.const_conditions(impl_def_id)
.iter_instantiated(cx, impl_args)
.map(|bound_trait_ref| {
- goal.with(cx, bound_trait_ref.to_host_effect_clause(cx, goal.predicate.host))
+ goal.with(
+ cx,
+ bound_trait_ref.to_host_effect_clause(cx, goal.predicate.constness),
+ )
});
ecx.add_goals(GoalSource::ImplWhereBound, const_conditions);
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index 05954143aee00..1a5c29afdc939 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -139,7 +139,7 @@ where
}
ty::ClauseKind::HostEffect(pred) => {
try_visit!(self.visit_trait(pred.trait_ref));
- pred.host.visit_with(self)
+ pred.constness.visit_with(self)
}
ty::ClauseKind::Projection(ty::ProjectionPredicate {
projection_term: projection_ty,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 6014ed555b64d..612e92ea7843d 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -545,10 +545,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
polarity: ty::PredicatePolarity::Positive,
}),
None,
- Some(match predicate.host {
- ty::HostPolarity::Maybe => ty::BoundConstness::ConstIfConst,
- ty::HostPolarity::Const => ty::BoundConstness::Const,
- }),
+ Some(predicate.constness),
None,
String::new(),
);
@@ -2238,18 +2235,16 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
(None, _) => Some(cannot_do_this),
// suggested using default post message
(
- Some(ty::BoundConstness::Const | ty::BoundConstness::ConstIfConst),
+ Some(ty::BoundConstness::Const | ty::BoundConstness::Maybe),
Some(AppendConstMessage::Default),
) => Some(format!("{cannot_do_this} in const contexts")),
// overridden post message
(
- Some(ty::BoundConstness::Const | ty::BoundConstness::ConstIfConst),
+ Some(ty::BoundConstness::Const | ty::BoundConstness::Maybe),
Some(AppendConstMessage::Custom(custom_msg, _)),
) => Some(format!("{cannot_do_this}{custom_msg}")),
// fallback to generic message
- (Some(ty::BoundConstness::Const | ty::BoundConstness::ConstIfConst), None) => {
- None
- }
+ (Some(ty::BoundConstness::Const | ty::BoundConstness::Maybe), None) => None,
}
})
.unwrap_or_else(|| {
diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
index 60b3357810a65..cb36f1a62dbfd 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -47,7 +47,7 @@ fn match_candidate<'tcx>(
obligation: &HostEffectObligation<'tcx>,
candidate: ty::Binder<'tcx, ty::HostEffectPredicate<'tcx>>,
) -> Result<ThinVec<PredicateObligation<'tcx>>, NoSolution> {
- if !candidate.skip_binder().host.satisfies(obligation.predicate.host) {
+ if !candidate.skip_binder().constness.satisfies(obligation.predicate.constness) {
return Err(NoSolution);
}
@@ -135,7 +135,8 @@ fn evaluate_host_effect_from_selection_candiate<'tcx>(
.map(|(trait_ref, _)| {
obligation.with(
tcx,
- trait_ref.to_host_effect_clause(tcx, obligation.predicate.host),
+ trait_ref
+ .to_host_effect_clause(tcx, obligation.predicate.constness),
)
}),
);
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index aa499995bcb9d..731d42fc006ca 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -155,7 +155,7 @@ fn param_env(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ParamEnv<'_> {
if tcx.is_conditionally_const(def_id) {
predicates.extend(
tcx.const_conditions(def_id).instantiate_identity(tcx).into_iter().map(
- |(trait_ref, _)| trait_ref.to_host_effect_clause(tcx, ty::HostPolarity::Maybe),
+ |(trait_ref, _)| trait_ref.to_host_effect_clause(tcx, ty::BoundConstness::Maybe),
),
);
}
diff --git a/compiler/rustc_type_ir/src/elaborate.rs b/compiler/rustc_type_ir/src/elaborate.rs
index 72d392ecd7bdc..3fbce7886edcb 100644
--- a/compiler/rustc_type_ir/src/elaborate.rs
+++ b/compiler/rustc_type_ir/src/elaborate.rs
@@ -160,7 +160,7 @@ impl<I: Interner, O: Elaboratable<I>> Elaborator<I, O> {
cx.implied_const_bounds(data.def_id()).iter_identity().map(|trait_ref| {
elaboratable.child(
trait_ref
- .to_host_effect_clause(cx, data.host)
+ .to_host_effect_clause(cx, data.constness)
.instantiate_supertrait(cx, bound_clause.rebind(data.trait_ref)),
)
}),
diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs
index c316455034873..0cade1d688553 100644
--- a/compiler/rustc_type_ir/src/predicate.rs
+++ b/compiler/rustc_type_ir/src/predicate.rs
@@ -112,9 +112,9 @@ impl<I: Interner> ty::Binder<I, TraitRef<I>> {
self.skip_binder().def_id
}
- pub fn to_host_effect_clause(self, cx: I, host: HostPolarity) -> I::Clause {
+ pub fn to_host_effect_clause(self, cx: I, constness: BoundConstness) -> I::Clause {
self.map_bound(|trait_ref| {
- ty::ClauseKind::HostEffect(HostEffectPredicate { trait_ref, host })
+ ty::ClauseKind::HostEffect(HostEffectPredicate { trait_ref, constness })
})
.upcast(cx)
}
@@ -757,7 +757,7 @@ impl<I: Interner> fmt::Debug for NormalizesTo<I> {
#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
pub struct HostEffectPredicate<I: Interner> {
pub trait_ref: ty::TraitRef<I>,
- pub host: HostPolarity,
+ pub constness: BoundConstness,
}
impl<I: Interner> HostEffectPredicate<I> {
@@ -785,28 +785,8 @@ impl<I: Interner> ty::Binder<I, HostEffectPredicate<I>> {
}
#[inline]
- pub fn host(self) -> HostPolarity {
- self.skip_binder().host
- }
-}
-
-#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
-#[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
-#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
-pub enum HostPolarity {
- /// May be called in const environments if the callee is const.
- Maybe,
- /// Always allowed to be called in const environments.
- Const,
-}
-
-impl HostPolarity {
- pub fn satisfies(self, goal: HostPolarity) -> bool {
- match (self, goal) {
- (HostPolarity::Const, HostPolarity::Const | HostPolarity::Maybe) => true,
- (HostPolarity::Maybe, HostPolarity::Maybe) => true,
- (HostPolarity::Maybe, HostPolarity::Const) => false,
- }
+ pub fn constness(self) -> BoundConstness {
+ self.skip_binder().constness
}
}
@@ -831,8 +811,8 @@ pub struct CoercePredicate<I: Interner> {
pub b: I::Ty,
}
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "nightly", derive(HashStable_NoContext, TyEncodable, TyDecodable))]
+#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
pub enum BoundConstness {
/// `Type: const Trait`
///
@@ -841,14 +821,22 @@ pub enum BoundConstness {
/// `Type: ~const Trait`
///
/// Requires resolving to const only when we are in a const context.
- ConstIfConst,
+ Maybe,
}
impl BoundConstness {
+ pub fn satisfies(self, goal: BoundConstness) -> bool {
+ match (self, goal) {
+ (BoundConstness::Const, BoundConstness::Const | BoundConstness::Maybe) => true,
+ (BoundConstness::Maybe, BoundConstness::Maybe) => true,
+ (BoundConstness::Maybe, BoundConstness::Const) => false,
+ }
+ }
+
pub fn as_str(self) -> &'static str {
match self {
Self::Const => "const",
- Self::ConstIfConst => "~const",
+ Self::Maybe => "~const",
}
}
}
@@ -857,14 +845,7 @@ impl fmt::Display for BoundConstness {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Const => f.write_str("const"),
- Self::ConstIfConst => f.write_str("~const"),
+ Self::Maybe => f.write_str("~const"),
}
}
}
-
-impl<I> Lift<I> for BoundConstness {
- type Lifted = BoundConstness;
- fn lift_to_interner(self, _: I) -> Option<Self::Lifted> {
- Some(self)
- }
-}