Change name

tiif · tiif · commit 9bf13e45a766 · 2025-04-21T18:20:12.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::UnstableImpl 
+                    | 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::UnstableImpl 
+                    | 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
@@ -496,7 +496,7 @@ fn trait_specialization_kind<'tcx>(
         | ty::ClauseKind::ConstArgHasType(..)
         | ty::ClauseKind::WellFormed(_)
         | ty::ClauseKind::ConstEvaluatable(..)
-        | ty::ClauseKind::UnstableImpl
+        | 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::UnstableImpl
+                    | 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::UnstableImpl)
+            | 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::UnstableImpl
+                | ty::ClauseKind::UnstableFeature
                 | ty::ClauseKind::HostEffect(..) => None,
             }
         });
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
@@ -1561,7 +1561,7 @@ impl<'tcx> LateLintPass<'tcx> for TrivialConstraints {
                     ClauseKind::TypeOutlives(..) |
                     ClauseKind::RegionOutlives(..) => "lifetime",
 
-                    ClauseKind::UnstableImpl
+                    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/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::UnstableImpl) => {}
+            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
@@ -132,7 +132,7 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::Clause(ClauseKind::TypeOutlives(_))
             | PredicateKind::Clause(ClauseKind::Projection(_))
             | PredicateKind::Clause(ClauseKind::ConstArgHasType(..))
-            | PredicateKind::Clause(ClauseKind::UnstableImpl)
+            | 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::UnstableImpl) 
+            | 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::UnstableImpl)
+            | 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
@@ -3251,7 +3251,7 @@ define_print! {
             ty::ClauseKind::ConstEvaluatable(ct) => {
                 p!("the constant `", print(ct), "` can be evaluated")
             }
-            ty::ClauseKind::UnstableImpl => p!("unstable impl"),
+            ty::ClauseKind::UnstableFeature => p!("unstable impl"),
         }
     }
 
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
@@ -557,7 +557,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::UnstableImpl) => 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_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
@@ -1783,7 +1783,7 @@ pub(crate) struct UnnecessaryPartialStableFeature {
 #[derive(LintDiagnostic)]
 #[diag(passes_ineffective_unstable_impl)]
 #[note]
-pub(crate) struct IneffectiveUnstableImpl;
+pub(crate) struct IneffectiveUnstableFeature;
 
 #[derive(LintDiagnostic)]
 #[diag(passes_unused_assign)]
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
@@ -821,7 +821,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                                 INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
                                 item.hir_id(),
                                 span,
-                                errors::IneffectiveUnstableImpl,
+                                errors::IneffectiveUnstableFeature,
                             );
                         }
                     }
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -158,7 +158,7 @@ where
             }
             ty::ClauseKind::ConstEvaluatable(ct) => ct.visit_with(self),
             ty::ClauseKind::WellFormed(arg) => arg.visit_with(self),
-            ty::ClauseKind::UnstableImpl => todo!(), // TODO: maybe we need a visit with function here too?
+            ty::ClauseKind::UnstableFeature => todo!(), // TODO: maybe we need a visit with function here too?
         }
     }
 
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -647,7 +647,7 @@ impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> {
             ClauseKind::HostEffect(..) => {
                 todo!()
             }
-            ClauseKind::UnstableImpl => {
+            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
@@ -638,7 +638,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         }
                     }
 
-                    ty::PredicateKind::Clause(ty::ClauseKind::UnstableImpl) => 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::UnstableImpl)
+                | 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::UnstableImpl
+        | 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::UnstableImpl
+        | 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::UnstableImpl) => 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::UnstableImpl) => 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::UnstableImpl)
+                | 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
@@ -837,7 +837,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     }
                 }
 
-                ty::PredicateKind::Clause(ty::ClauseKind::UnstableImpl) => 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::UnstableImpl
+            | 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
@@ -196,7 +196,7 @@ pub fn clause_obligations<'tcx>(
         ty::ClauseKind::ConstEvaluatable(ct) => {
             wf.compute(ct.into());
         }
-        ty::ClauseKind::UnstableImpl => {}
+        ty::ClauseKind::UnstableFeature => {}
     }
 
     wf.normalize(infcx)
@@ -1065,7 +1065,7 @@ pub fn object_region_bounds<'tcx>(
                 | ty::ClauseKind::Projection(_)
                 | ty::ClauseKind::ConstArgHasType(_, _)
                 | ty::ClauseKind::WellFormed(_)
-                | ty::ClauseKind::UnstableImpl
+                | 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::UnstableImpl)
+        | 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::UnstableImpl => {
+            ty::ClauseKind::UnstableFeature => {
                 // TODO: come back later and add more stuff if needed.
             }
         }
diff --git a/compiler/rustc_type_ir/src/predicate_kind.rs b/compiler/rustc_type_ir/src/predicate_kind.rs
@@ -47,8 +47,8 @@ pub enum ClauseKind<I: Interner> {
     /// implementation.
     HostEffect(ty::HostEffectPredicate<I>),
 
-    /// Support marking impl as unstable. 
-    UnstableImpl,
+    /// Support marking impl as unstable.
+    UnstableFeature,
 }
 
 #[derive_where(Clone, Copy, Hash, PartialEq, Eq; I: Interner)]
@@ -137,7 +137,7 @@ impl<I: Interner> fmt::Debug for ClauseKind<I> {
             ClauseKind::ConstEvaluatable(ct) => {
                 write!(f, "ConstEvaluatable({ct:?})")
             }
-            ClauseKind::UnstableImpl => write!(f, "UnstableImpl"),
+            ClauseKind::UnstableFeature => write!(f, "UnstableFeature"),
         }
     }
 }
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::UnstableImpl => todo!(),
+        ty::ClauseKind::UnstableFeature => todo!(),
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -496,7 +496,7 @@ fn trait_specialization_kind<'tcx>(`
`496`	`496`	`\| ty::ClauseKind::ConstArgHasType(..)`
`497`	`497`	`\| ty::ClauseKind::WellFormed(_)`
`498`	`498`	`\| ty::ClauseKind::ConstEvaluatable(..)`
`499`		`- \| ty::ClauseKind::UnstableImpl`
	`499`	`+ \| ty::ClauseKind::UnstableFeature`
`500`	`500`	`\| ty::ClauseKind::HostEffect(..) => None,`
`501`	`501`	`}`
`502`	`502`	`}`
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::UnstableImpl`
	`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::UnstableImpl)`
	`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::UnstableImpl`
	`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::UnstableImpl) => {}`
	`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
`@@ -3251,7 +3251,7 @@ define_print! {`
`3251`	`3251`	`ty::ClauseKind::ConstEvaluatable(ct) => {`
`3252`	`3252`	p!("the constant `", print(ct), "` can be evaluated")
`3253`	`3253`	`}`
`3254`		`- ty::ClauseKind::UnstableImpl => p!("unstable impl"),`
	`3254`	`+ ty::ClauseKind::UnstableFeature => p!("unstable impl"),`
`3255`	`3255`	`}`
`3256`	`3256`	`}`
`3257`	`3257`
Original file line number	Diff line number	Diff line change
`@@ -557,7 +557,7 @@ where`
`557`	`557`	`ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, ty)) => {`
`558`	`558`	`self.compute_const_arg_has_type_goal(Goal { param_env, predicate: (ct, ty) })`
`559`	`559`	`}`
`560`		`- ty::PredicateKind::Clause(ty::ClauseKind::UnstableImpl) => todo!(),`
	`560`	`+ ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature) => todo!(),`
`561`	`561`	`ty::PredicateKind::Subtype(predicate) => {`
`562`	`562`	`self.compute_subtype_goal(Goal { param_env, predicate })`
`563`	`563`	`}`