Add Symbol to UnstableFeature ClauseKind

tiif · tiif · commit 9a0f289a3599 · 2025-05-23T08:44:05.000Z
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -747,7 +747,7 @@ pub(super) fn assert_only_contains_predicates_from<'tcx>(
                     ty::ClauseKind::RegionOutlives(_)
                     | ty::ClauseKind::ConstArgHasType(_, _)
                     | ty::ClauseKind::WellFormed(_)
-                    | ty::ClauseKind::UnstableFeature
+                    | ty::ClauseKind::UnstableFeature(_) 
                     | ty::ClauseKind::ConstEvaluatable(_) => {
                         bug!(
                             "unexpected non-`Self` predicate when computing \
@@ -775,7 +775,7 @@ pub(super) fn assert_only_contains_predicates_from<'tcx>(
                     | ty::ClauseKind::ConstArgHasType(_, _)
                     | ty::ClauseKind::WellFormed(_)
                     | ty::ClauseKind::ConstEvaluatable(_)
-                    | ty::ClauseKind::UnstableFeature
+                    | ty::ClauseKind::UnstableFeature(_) 
                     | ty::ClauseKind::HostEffect(..) => {
                         bug!(
                             "unexpected non-`Self` predicate when computing \
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs b/compiler/rustc_hir_analysis/src/impl_wf_check/min_specialization.rs
@@ -499,7 +499,7 @@ fn trait_specialization_kind<'tcx>(
         | ty::ClauseKind::ConstArgHasType(..)
         | ty::ClauseKind::WellFormed(_)
         | ty::ClauseKind::ConstEvaluatable(..)
-        | ty::ClauseKind::UnstableFeature
+        | ty::ClauseKind::UnstableFeature(_)
         | ty::ClauseKind::HostEffect(..) => None,
     }
 }
diff --git a/compiler/rustc_hir_analysis/src/outlives/explicit.rs b/compiler/rustc_hir_analysis/src/outlives/explicit.rs
@@ -54,7 +54,7 @@ impl<'tcx> ExplicitPredicatesMap<'tcx> {
                     | ty::ClauseKind::ConstArgHasType(_, _)
                     | ty::ClauseKind::WellFormed(_)
                     | ty::ClauseKind::ConstEvaluatable(_)
-                    | ty::ClauseKind::UnstableFeature
+                    | ty::ClauseKind::UnstableFeature(_)
                     | ty::ClauseKind::HostEffect(..) => {}
                 }
             }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/inspect_obligations.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/inspect_obligations.rs
@@ -53,7 +53,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             | ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))
             | ty::PredicateKind::ConstEquate(..)
             | ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(..))
-            | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature)
+            | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_))
             | ty::PredicateKind::Ambiguous => false,
         }
     }
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -926,7 +926,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 | ty::ClauseKind::ConstArgHasType(_, _)
                 | ty::ClauseKind::WellFormed(_)
                 | ty::ClauseKind::ConstEvaluatable(_)
-                | ty::ClauseKind::UnstableFeature
+                | ty::ClauseKind::UnstableFeature(_)
                 | ty::ClauseKind::HostEffect(..) => None,
             }
         });
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
@@ -1568,7 +1568,7 @@ impl<'tcx> LateLintPass<'tcx> for TrivialConstraints {
                     ClauseKind::TypeOutlives(..) |
                     ClauseKind::RegionOutlives(..) => "lifetime",
 
-                    ClauseKind::UnstableFeature
+                    ClauseKind::UnstableFeature(_)
                     // `ConstArgHasType` is never global as `ct` is always a param
                     | ClauseKind::ConstArgHasType(..)
                     // Ignore projections, as they can only be global
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -129,6 +129,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     type FnInputTys = &'tcx [Ty<'tcx>];
     type ParamTy = ParamTy;
     type BoundTy = ty::BoundTy;
+    type Symbol = Symbol;
 
     type PlaceholderTy = ty::PlaceholderType;
     type ErrorGuaranteed = ErrorGuaranteed;
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
@@ -309,7 +309,7 @@ impl FlagComputation {
             ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(arg)) => {
                 self.add_args(slice::from_ref(&arg));
             }
-            ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature) => {}
+            ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_)) => {}
             ty::PredicateKind::DynCompatible(_def_id) => {}
             ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(uv)) => {
                 self.add_const(uv);
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
@@ -131,7 +131,7 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::Clause(ClauseKind::TypeOutlives(_))
             | PredicateKind::Clause(ClauseKind::Projection(_))
             | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
-            | PredicateKind::Clause(ClauseKind::UnstableFeature)
+            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
             | PredicateKind::DynCompatible(_)
             | PredicateKind::Subtype(_)
             | PredicateKind::Coerce(_)
@@ -648,7 +648,7 @@ impl<'tcx> Predicate<'tcx> {
             PredicateKind::Clause(ClauseKind::Projection(..))
             | PredicateKind::Clause(ClauseKind::HostEffect(..))
             | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
-            | PredicateKind::Clause(ClauseKind::UnstableFeature)
+            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
             | PredicateKind::NormalizesTo(..)
             | PredicateKind::AliasRelate(..)
             | PredicateKind::Subtype(..)
@@ -670,7 +670,7 @@ impl<'tcx> Predicate<'tcx> {
             PredicateKind::Clause(ClauseKind::Trait(..))
             | PredicateKind::Clause(ClauseKind::HostEffect(..))
             | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
-            | PredicateKind::Clause(ClauseKind::UnstableFeature)
+            | PredicateKind::Clause(ClauseKind::UnstableFeature(_))
             | PredicateKind::NormalizesTo(..)
             | PredicateKind::AliasRelate(..)
             | PredicateKind::Subtype(..)
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -3250,7 +3250,7 @@ define_print! {
             ty::ClauseKind::ConstEvaluatable(ct) => {
                 p!("the constant `", print(ct), "` can be evaluated")
             }
-            ty::ClauseKind::UnstableFeature => p!("unstable impl"),
+            ty::ClauseKind::UnstableFeature(_) => p!("unstable impl"), // TODO: fix this later
         }
     }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -528,7 +528,7 @@ where
                 ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, ty)) => {
                     self.compute_const_arg_has_type_goal(Goal { param_env, predicate: (ct, ty) })
                 }
-                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature) => todo!(),
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_)) => todo!(),
                 ty::PredicateKind::Subtype(predicate) => {
                     self.compute_subtype_goal(Goal { param_env, predicate })
                 }
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -155,9 +155,14 @@ where
                 ty.visit_with(self)
             }
             ty::ClauseKind::ConstEvaluatable(ct) => ct.visit_with(self),
+<<<<<<< HEAD
             ty::ClauseKind::WellFormed(term) => term.visit_with(self),
             ty::ClauseKind::UnstableImpl => todo!(), // TODO: maybe we need a visit with function here too?leFeature => todo!(), // TODO: maybe we need a visit with function here too?
 
+=======
+            ty::ClauseKind::WellFormed(arg) => arg.visit_with(self),
+            ty::ClauseKind::UnstableFeature(_) => todo!(), // TODO: maybe we need a visit with function here too?
+>>>>>>> 4df12515651 (Add Symbol to UnstableFeature ClauseKind)
         }
     }
 
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -648,7 +648,7 @@ impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> {
             ClauseKind::HostEffect(..) => {
                 todo!()
             }
-            ClauseKind::UnstableFeature => {
+            ClauseKind::UnstableFeature(_) => {
                 todo!()
             }
         }
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
@@ -639,7 +639,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         }
                     }
 
-                    ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature) => todo!(), // TODO: is this for error reporting?
+                    ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_)) => todo!(), // TODO: is this for error reporting?
 
                     // Errors for `ConstEvaluatable` predicates show up as
                     // `SelectionError::ConstEvalFailure`,
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -798,7 +798,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                 // FIXME(generic_const_exprs): you can absolutely add this as a where clauses
                 | ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))
                 | ty::PredicateKind::Coerce(..)
-                | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature)
+                | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_))
                 | ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(..)) => {}
                 ty::PredicateKind::Ambiguous => return false,
             };
diff --git a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
@@ -238,7 +238,7 @@ fn predicate_references_self<'tcx>(
         // FIXME(generic_const_exprs): this can mention `Self`
         | ty::ClauseKind::ConstEvaluatable(..)
         | ty::ClauseKind::HostEffect(..)
-        | ty::ClauseKind::UnstableFeature
+        | ty::ClauseKind::UnstableFeature(_)
          => None,
     }
 }
@@ -279,7 +279,7 @@ fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
         | ty::ClauseKind::ConstArgHasType(_, _)
         | ty::ClauseKind::WellFormed(_)
         | ty::ClauseKind::ConstEvaluatable(_)
-        | ty::ClauseKind::UnstableFeature
+        | ty::ClauseKind::UnstableFeature(_)
         | ty::ClauseKind::HostEffect(..) => false,
     })
 }
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -404,7 +404,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                 ty::PredicateKind::AliasRelate(..) => {
                     bug!("AliasRelate is only used by the new solver")
                 }
-                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature) => todo!(), // TODO: not sure what will happen here. 
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_)) => todo!(), // TODO: not sure what will happen here. 
             },
             Some(pred) => match pred {
                 ty::PredicateKind::Clause(ty::ClauseKind::Trait(data)) => {
@@ -762,7 +762,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                         }
                     }
                 }
-                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature) => todo!(),
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_)) => todo!(),
             },
         }
     }
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
@@ -110,7 +110,7 @@ pub fn compute_implied_outlives_bounds_inner<'tcx>(
                 | ty::PredicateKind::ConstEquate(..)
                 | ty::PredicateKind::Ambiguous
                 | ty::PredicateKind::NormalizesTo(..)
-                | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature)
+                | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_))
                 | ty::PredicateKind::AliasRelate(..) => {}
 
                 // We need to search through *all* WellFormed predicates
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -838,7 +838,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     }
                 }
 
-                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature) => todo!(),
+                ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_)) => todo!(),
 
                 ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(uv)) => {
                     match const_evaluatable::is_const_evaluatable(
diff --git a/compiler/rustc_trait_selection/src/traits/util.rs b/compiler/rustc_trait_selection/src/traits/util.rs
@@ -76,7 +76,7 @@ pub fn expand_trait_aliases<'tcx>(
             | ty::ClauseKind::ConstArgHasType(_, _)
             | ty::ClauseKind::WellFormed(_)
             | ty::ClauseKind::ConstEvaluatable(_)
-            | ty::ClauseKind::UnstableFeature
+            | ty::ClauseKind::UnstableFeature(_)
             | ty::ClauseKind::HostEffect(..) => {}
         }
     }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -197,7 +197,7 @@ pub fn clause_obligations<'tcx>(
         ty::ClauseKind::ConstEvaluatable(ct) => {
             wf.add_wf_preds_for_term(ct.into());
         }
-        ty::ClauseKind::UnstableFeature => {}
+        ty::ClauseKind::UnstableFeature(_) => {}
     }
 
     wf.normalize(infcx)
@@ -1088,7 +1088,7 @@ pub fn object_region_bounds<'tcx>(
                 | ty::ClauseKind::Projection(_)
                 | ty::ClauseKind::ConstArgHasType(_, _)
                 | ty::ClauseKind::WellFormed(_)
-                | ty::ClauseKind::UnstableFeature
+                | ty::ClauseKind::UnstableFeature(_)
                 | ty::ClauseKind::ConstEvaluatable(_) => None,
             }
         })
diff --git a/compiler/rustc_traits/src/normalize_erasing_regions.rs b/compiler/rustc_traits/src/normalize_erasing_regions.rs
@@ -57,7 +57,7 @@ fn not_outlives_predicate(p: ty::Predicate<'_>) -> bool {
         | ty::PredicateKind::Clause(ty::ClauseKind::Projection(..))
         | ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(..))
         | ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(..))
-        | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature)
+        | ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_))
         | ty::PredicateKind::NormalizesTo(..)
         | ty::PredicateKind::AliasRelate(..)
         | ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(..))
diff --git a/compiler/rustc_type_ir/src/elaborate.rs b/compiler/rustc_type_ir/src/elaborate.rs
@@ -200,7 +200,7 @@ impl<I: Interner, O: Elaboratable<I>> Elaborator<I, O> {
             ty::ClauseKind::ConstArgHasType(..) => {
                 // Nothing to elaborate
             }
-            ty::ClauseKind::UnstableFeature => {
+            ty::ClauseKind::UnstableFeature(_) => {
                 // TODO: come back later and add more stuff if needed.
             }
         }
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
@@ -100,6 +100,7 @@ pub trait Interner:
     type ParamTy: Copy + Debug + Hash + Eq + ParamLike;
     type BoundTy: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
     type PlaceholderTy: PlaceholderLike;
+    type Symbol: Copy + Hash + PartialEq + Eq + TypeFoldable<Self> + TypeVisitable<Self>; // TODO: add more trait if we need it, keep it minimal for now.
 
     // Things stored inside of tys
     type ErrorGuaranteed: Copy + Debug + Hash + Eq;
diff --git a/compiler/rustc_type_ir/src/predicate_kind.rs b/compiler/rustc_type_ir/src/predicate_kind.rs
@@ -1,5 +1,6 @@
 use std::fmt;
 
+
 use derive_where::derive_where;
 #[cfg(feature = "nightly")]
 use rustc_macros::{Decodable_NoContext, Encodable_NoContext, HashStable_NoContext};
@@ -48,7 +49,7 @@ pub enum ClauseKind<I: Interner> {
     HostEffect(ty::HostEffectPredicate<I>),
 
     /// Support marking impl as unstable.
-    UnstableFeature,
+    UnstableFeature(I::Symbol),
 }
 
 #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
@@ -137,7 +138,7 @@ impl<I: Interner> fmt::Debug for ClauseKind<I> {
             ClauseKind::ConstEvaluatable(ct) => {
                 write!(f, "ConstEvaluatable({ct:?})")
             }
-            ClauseKind::UnstableFeature => write!(f, "UnstableFeature"),
+            ClauseKind::UnstableFeature(feature_name) => write!(f, "UnstableFeature({feature_name:?})"),
         }
     }
 }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -398,7 +398,7 @@ pub(crate) fn clean_predicate<'tcx>(
         | ty::ClauseKind::ConstArgHasType(..)
         // FIXME(const_trait_impl): We can probably use this `HostEffect` pred to render `~const`.
         | ty::ClauseKind::HostEffect(_) => None,
-        ty::ClauseKind::UnstableFeature => todo!(),
+        ty::ClauseKind::UnstableFeature(_) => todo!(),
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -499,7 +499,7 @@ fn trait_specialization_kind<'tcx>(`
`499`	`499`	`\| ty::ClauseKind::ConstArgHasType(..)`
`500`	`500`	`\| ty::ClauseKind::WellFormed(_)`
`501`	`501`	`\| ty::ClauseKind::ConstEvaluatable(..)`
`502`		`- \| ty::ClauseKind::UnstableFeature`
	`502`	`+ \| ty::ClauseKind::UnstableFeature(_)`
`503`	`503`	`\| ty::ClauseKind::HostEffect(..) => None,`
`504`	`504`	`}`
`505`	`505`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ impl<'tcx> ExplicitPredicatesMap<'tcx> {`
`54`	`54`	`\| ty::ClauseKind::ConstArgHasType(_, _)`
`55`	`55`	`\| ty::ClauseKind::WellFormed(_)`
`56`	`56`	`\| ty::ClauseKind::ConstEvaluatable(_)`
`57`		`- \| ty::ClauseKind::UnstableFeature`
	`57`	`+ \| ty::ClauseKind::UnstableFeature(_)`
`58`	`58`	`\| ty::ClauseKind::HostEffect(..) => {}`
`59`	`59`	`}`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`53`	`53`	`\| ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))`
`54`	`54`	`\| ty::PredicateKind::ConstEquate(..)`
`55`	`55`	`\| ty::PredicateKind::Clause(ty::ClauseKind::HostEffect(..))`
`56`		`- \| ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature)`
	`56`	`+ \| ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_))`
`57`	`57`	`\| ty::PredicateKind::Ambiguous => false,`
`58`	`58`	`}`
`59`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -926,7 +926,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {`
`926`	`926`	`\| ty::ClauseKind::ConstArgHasType(_, _)`
`927`	`927`	`\| ty::ClauseKind::WellFormed(_)`
`928`	`928`	`\| ty::ClauseKind::ConstEvaluatable(_)`
`929`		`- \| ty::ClauseKind::UnstableFeature`
	`929`	`+ \| ty::ClauseKind::UnstableFeature(_)`
`930`	`930`	`\| ty::ClauseKind::HostEffect(..) => None,`
`931`	`931`	`}`
`932`	`932`	`});`
Original file line number	Diff line number	Diff line change
`@@ -309,7 +309,7 @@ impl FlagComputation {`
`309`	`309`	`ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(arg)) => {`
`310`	`310`	`self.add_args(slice::from_ref(&arg));`
`311`	`311`	`}`
`312`		`- ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature) => {}`
	`312`	`+ ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_)) => {}`
`313`	`313`	`ty::PredicateKind::DynCompatible(_def_id) => {}`
`314`	`314`	`ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(uv)) => {`
`315`	`315`	`self.add_const(uv);`
Original file line number	Diff line number	Diff line change
`@@ -3250,7 +3250,7 @@ define_print! {`
`3250`	`3250`	`ty::ClauseKind::ConstEvaluatable(ct) => {`
`3251`	`3251`	p!("the constant `", print(ct), "` can be evaluated")
`3252`	`3252`	`}`
`3253`		`- ty::ClauseKind::UnstableFeature => p!("unstable impl"),`
	`3253`	`+ ty::ClauseKind::UnstableFeature(_) => p!("unstable impl"), // TODO: fix this later`
`3254`	`3254`	`}`
`3255`	`3255`	`}`
`3256`	`3256`