remove TypeWellFormedFromEnv

compiler-errors · compiler-errors · commit 0c73b41cd69c · 2023-07-03T21:40:04.000Z
diff --git a/compiler/rustc_hir_analysis/src/astconv/mod.rs b/compiler/rustc_hir_analysis/src/astconv/mod.rs
@@ -983,8 +983,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                 ty::ClauseKind::RegionOutlives(_)
                 | ty::ClauseKind::ConstArgHasType(..)
                 | ty::ClauseKind::WellFormed(_)
-                | ty::ClauseKind::ConstEvaluatable(_)
-                | ty::ClauseKind::TypeWellFormedFromEnv(_) => {
+                | ty::ClauseKind::ConstEvaluatable(_) => {
                     bug!()
                 }
             }
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
@@ -551,7 +551,6 @@ fn trait_predicate_kind<'tcx>(
         | ty::PredicateKind::ClosureKind(..)
         | ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))
         | ty::PredicateKind::ConstEquate(..)
-        | ty::PredicateKind::Ambiguous
-        | ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => None,
+        | ty::PredicateKind::Ambiguous => None,
     }
 }
diff --git a/compiler/rustc_hir_analysis/src/outlives/explicit.rs b/compiler/rustc_hir_analysis/src/outlives/explicit.rs
@@ -53,8 +53,7 @@ impl<'tcx> ExplicitPredicatesMap<'tcx> {
                     | ty::ClauseKind::Projection(_)
                     | ty::ClauseKind::ConstArgHasType(_, _)
                     | ty::ClauseKind::WellFormed(_)
-                    | ty::ClauseKind::ConstEvaluatable(_)
-                    | ty::ClauseKind::TypeWellFormedFromEnv(_) => {}
+                    | ty::ClauseKind::ConstEvaluatable(_) => {}
                 }
             }
 
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -685,7 +685,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // inference variable.
                 | ty::PredicateKind::ClosureKind(..)
                 | ty::PredicateKind::Ambiguous
-                | ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => None,
+                 => None,
             },
         )
     }
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -847,8 +847,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 | ty::ClauseKind::Projection(_)
                 | ty::ClauseKind::ConstArgHasType(_, _)
                 | ty::ClauseKind::WellFormed(_)
-                | ty::ClauseKind::ConstEvaluatable(_)
-                | ty::ClauseKind::TypeWellFormedFromEnv(_) => None,
+                | ty::ClauseKind::ConstEvaluatable(_) => None,
             }
         });
 
diff --git a/compiler/rustc_infer/src/infer/outlives/mod.rs b/compiler/rustc_infer/src/infer/outlives/mod.rs
@@ -31,8 +31,7 @@ pub fn explicit_outlives_bounds<'tcx>(
             | ty::ClauseKind::Projection(_)
             | ty::ClauseKind::ConstArgHasType(_, _)
             | ty::ClauseKind::WellFormed(_)
-            | ty::ClauseKind::ConstEvaluatable(_)
-            | ty::ClauseKind::TypeWellFormedFromEnv(_) => None,
+            | ty::ClauseKind::ConstEvaluatable(_) => None,
         })
 }
 
diff --git a/compiler/rustc_infer/src/traits/util.rs b/compiler/rustc_infer/src/traits/util.rs
@@ -370,9 +370,6 @@ impl<'tcx, O: Elaboratable<'tcx>> Elaborator<'tcx, O> {
                         }),
                 );
             }
-            ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => {
-                // Nothing to elaborate
-            }
             ty::PredicateKind::Ambiguous => {}
             ty::PredicateKind::AliasRelate(..) => {
                 // No
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
@@ -1606,8 +1606,7 @@ impl<'tcx> LateLintPass<'tcx> for TrivialConstraints {
                     // Ignore bounds that a user can't type
                     | ClauseKind::WellFormed(..)
                     // FIXME(generic_const_exprs): `ConstEvaluatable` can be written
-                    | ClauseKind::ConstEvaluatable(..)
-                    | ClauseKind::TypeWellFormedFromEnv(_)  => continue,
+                    | ClauseKind::ConstEvaluatable(..)  => continue,
                 };
                 if predicate.is_global() {
                     cx.emit_spanned_lint(
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
@@ -287,9 +287,6 @@ impl FlagComputation {
                 self.add_const(expected);
                 self.add_const(found);
             }
-            ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(ty)) => {
-                self.add_ty(ty);
-            }
             ty::PredicateKind::Ambiguous => {}
             ty::PredicateKind::AliasRelate(t1, t2, _) => {
                 self.add_term(t1);
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -554,8 +554,7 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::Coerce(_)
             | PredicateKind::Clause(ClauseKind::ConstEvaluatable(_))
             | PredicateKind::ConstEquate(_, _)
-            | PredicateKind::Ambiguous
-            | PredicateKind::Clause(ClauseKind::TypeWellFormedFromEnv(_)) => true,
+            | PredicateKind::Ambiguous => true,
         }
     }
 }
@@ -661,11 +660,6 @@ pub enum ClauseKind<'tcx> {
 
     /// Constant initializer must evaluate successfully.
     ConstEvaluatable(ty::Const<'tcx>),
-
-    /// Represents a type found in the environment that we can use for implied bounds.
-    ///
-    /// Only used for Chalk.
-    TypeWellFormedFromEnv(Ty<'tcx>),
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
@@ -1424,8 +1418,7 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::Clause(ClauseKind::TypeOutlives(..))
             | PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))
             | PredicateKind::ConstEquate(..)
-            | PredicateKind::Ambiguous
-            | PredicateKind::Clause(ClauseKind::TypeWellFormedFromEnv(..)) => None,
+            | PredicateKind::Ambiguous => None,
         }
     }
 
@@ -1445,8 +1438,7 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::Clause(ClauseKind::TypeOutlives(..))
             | PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))
             | PredicateKind::ConstEquate(..)
-            | PredicateKind::Ambiguous
-            | PredicateKind::Clause(ClauseKind::TypeWellFormedFromEnv(..)) => None,
+            | PredicateKind::Ambiguous => None,
         }
     }
 
@@ -1466,8 +1458,7 @@ impl<'tcx> Predicate<'tcx> {
             | PredicateKind::ClosureKind(..)
             | PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))
             | PredicateKind::ConstEquate(..)
-            | PredicateKind::Ambiguous
-            | PredicateKind::Clause(ClauseKind::TypeWellFormedFromEnv(..)) => None,
+            | PredicateKind::Ambiguous => None,
         }
     }
 
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -2888,9 +2888,6 @@ define_print_and_forward_display! {
             ty::ClauseKind::ConstEvaluatable(ct) => {
                 p!("the constant `", print(ct), "` can be evaluated")
             }
-            ty::ClauseKind::TypeWellFormedFromEnv(ty) => {
-                p!("the type `", print(ty), "` is found in the environment")
-            }
         }
     }
 
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -189,9 +189,6 @@ impl<'tcx> fmt::Debug for ty::ClauseKind<'tcx> {
             ty::ClauseKind::ConstEvaluatable(ct) => {
                 write!(f, "ConstEvaluatable({ct:?})")
             }
-            ty::ClauseKind::TypeWellFormedFromEnv(ty) => {
-                write!(f, "TypeWellFormedFromEnv({:?})", ty)
-            }
         }
     }
 }
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -174,7 +174,6 @@ where
             }
             ty::ClauseKind::ConstEvaluatable(ct) => ct.visit_with(self),
             ty::ClauseKind::WellFormed(arg) => arg.visit_with(self),
-            ty::ClauseKind::TypeWellFormedFromEnv(_) => bug!("unexpected clause: {clause}"),
         }
     }
 
diff --git a/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs b/compiler/rustc_trait_selection/src/solve/eval_ctxt.rs
@@ -435,9 +435,6 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
                 ty::PredicateKind::ConstEquate(_, _) => {
                     bug!("ConstEquate should not be emitted when `-Ztrait-solver=next` is active")
                 }
-                ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => {
-                    bug!("TypeWellFormedFromEnv is only used for Chalk")
-                }
                 ty::PredicateKind::AliasRelate(lhs, rhs, direction) => self
                     .compute_alias_relate_goal(Goal {
                         param_env,
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -836,9 +836,6 @@ 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::TypeWellFormedFromEnv(..)) => {
-                    bug!("predicate should only exist in the environment: {bound_predicate:?}")
-                }
                 ty::PredicateKind::Ambiguous => return false,
             };
         }
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -1094,13 +1094,6 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
 
                     ty::PredicateKind::Ambiguous => span_bug!(span, "ambiguous"),
 
-                    ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => {
-                        span_bug!(
-                            span,
-                            "TypeWellFormedFromEnv predicate should only exist in the environment"
-                        )
-                    }
-
                     ty::PredicateKind::AliasRelate(..) => span_bug!(
                         span,
                         "AliasRelate predicate should never be the predicate cause of a SelectionError"
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -359,9 +359,6 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                     ProcessResult::Changed(mk_pending(vec![obligation.with(infcx.tcx, pred)]))
                 }
                 ty::PredicateKind::Ambiguous => ProcessResult::Unchanged,
-                ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => {
-                    bug!("TypeWellFormedFromEnv is only used for Chalk")
-                }
                 ty::PredicateKind::AliasRelate(..) => {
                     bug!("AliasRelate is only used for new solver")
                 }
@@ -627,9 +624,6 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                     }
                 }
                 ty::PredicateKind::Ambiguous => ProcessResult::Unchanged,
-                ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => {
-                    bug!("TypeWellFormedFromEnv is only used for Chalk")
-                }
                 ty::PredicateKind::AliasRelate(..) => {
                     bug!("AliasRelate is only used for new solver")
                 }
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -311,7 +311,7 @@ fn predicate_references_self<'tcx>(
         | ty::ClauseKind::RegionOutlives(..)
         // FIXME(generic_const_exprs): this can mention `Self`
         | ty::ClauseKind::ConstEvaluatable(..)
-        | ty::ClauseKind::TypeWellFormedFromEnv(_) => None,
+         => None,
     }
 }
 
@@ -351,8 +351,7 @@ fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
         | ty::ClauseKind::Projection(_)
         | ty::ClauseKind::ConstArgHasType(_, _)
         | ty::ClauseKind::WellFormed(_)
-        | ty::ClauseKind::ConstEvaluatable(_)
-        | ty::ClauseKind::TypeWellFormedFromEnv(_) => false,
+        | ty::ClauseKind::ConstEvaluatable(_) => false,
     })
 }
 
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
@@ -134,7 +134,7 @@ pub fn compute_implied_outlives_bounds_inner<'tcx>(
                 | ty::PredicateKind::ConstEquate(..)
                 | ty::PredicateKind::Ambiguous
                 | ty::PredicateKind::AliasRelate(..)
-                | ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => {}
+                 => {}
 
                 // We need to search through *all* WellFormed predicates
                 ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(arg)) => {
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -972,9 +972,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         }
                     }
                 }
-                ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => {
-                    bug!("TypeWellFormedFromEnv is only used for chalk")
-                }
                 ty::PredicateKind::AliasRelate(..) => {
                     bug!("AliasRelate is only used for new solver")
                 }
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -184,8 +184,7 @@ pub fn predicate_obligations<'tcx>(
         | ty::PredicateKind::Coerce(..)
         | ty::PredicateKind::ConstEquate(..)
         | ty::PredicateKind::Ambiguous
-        | ty::PredicateKind::AliasRelate(..)
-        | ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => {
+        | ty::PredicateKind::AliasRelate(..) => {
             bug!("We should only wf check where clauses, unexpected predicate: {predicate:?}")
         }
     }
@@ -1005,8 +1004,7 @@ pub(crate) fn required_region_bounds<'tcx>(
                 | ty::ClauseKind::Projection(_)
                 | ty::ClauseKind::ConstArgHasType(_, _)
                 | ty::ClauseKind::WellFormed(_)
-                | ty::ClauseKind::ConstEvaluatable(_)
-                | ty::ClauseKind::TypeWellFormedFromEnv(_) => None,
+                | ty::ClauseKind::ConstEvaluatable(_) => None,
             }
         })
         .collect()
diff --git a/compiler/rustc_traits/src/normalize_erasing_regions.rs b/compiler/rustc_traits/src/normalize_erasing_regions.rs
@@ -69,7 +69,6 @@ fn not_outlives_predicate(p: ty::Predicate<'_>) -> bool {
         | ty::PredicateKind::Coerce(..)
         | ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))
         | ty::PredicateKind::ConstEquate(..)
-        | ty::PredicateKind::Ambiguous
-        | ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => true,
+        | ty::PredicateKind::Ambiguous => true,
     }
 }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -342,8 +342,7 @@ pub(crate) fn clean_predicate<'tcx>(
         // FIXME(generic_const_exprs): should this do something?
         ty::ClauseKind::ConstEvaluatable(..)
         | ty::ClauseKind::WellFormed(..)
-        | ty::ClauseKind::ConstArgHasType(..)
-        | ty::ClauseKind::TypeWellFormedFromEnv(..) => None,
+        | ty::ClauseKind::ConstArgHasType(..) => None,
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -983,8 +983,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {`
`983`	`983`	`ty::ClauseKind::RegionOutlives(_)`
`984`	`984`	`\| ty::ClauseKind::ConstArgHasType(..)`
`985`	`985`	`\| ty::ClauseKind::WellFormed(_)`
`986`		`- \| ty::ClauseKind::ConstEvaluatable(_)`
`987`		`- \| ty::ClauseKind::TypeWellFormedFromEnv(_) => {`
	`986`	`+ \| ty::ClauseKind::ConstEvaluatable(_) => {`
`988`	`987`	`bug!()`
`989`	`988`	`}`
`990`	`989`	`}`
Original file line number	Diff line number	Diff line change
`@@ -551,7 +551,6 @@ fn trait_predicate_kind<'tcx>(`
`551`	`551`	`\| ty::PredicateKind::ClosureKind(..)`
`552`	`552`	`\| ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(..))`
`553`	`553`	`\| ty::PredicateKind::ConstEquate(..)`
`554`		`- \| ty::PredicateKind::Ambiguous`
`555`		`- \| ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => None,`
	`554`	`+ \| ty::PredicateKind::Ambiguous => None,`
`556`	`555`	`}`
`557`	`556`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,8 +53,7 @@ impl<'tcx> ExplicitPredicatesMap<'tcx> {`
`53`	`53`	`\| ty::ClauseKind::Projection(_)`
`54`	`54`	`\| ty::ClauseKind::ConstArgHasType(_, _)`
`55`	`55`	`\| ty::ClauseKind::WellFormed(_)`
`56`		`- \| ty::ClauseKind::ConstEvaluatable(_)`
`57`		`- \| ty::ClauseKind::TypeWellFormedFromEnv(_) => {}`
	`56`	`+ \| ty::ClauseKind::ConstEvaluatable(_) => {}`
`58`	`57`	`}`
`59`	`58`	`}`
`60`	`59`
Original file line number	Diff line number	Diff line change
`@@ -685,7 +685,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`685`	`685`	`// inference variable.`
`686`	`686`	`\| ty::PredicateKind::ClosureKind(..)`
`687`	`687`	`\| ty::PredicateKind::Ambiguous`
`688`		`- \| ty::PredicateKind::Clause(ty::ClauseKind::TypeWellFormedFromEnv(..)) => None,`
	`688`	`+ => None,`
`689`	`689`	`},`
`690`	`690`	`)`
`691`	`691`	`}`
Original file line number	Diff line number	Diff line change
`@@ -847,8 +847,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {`
`847`	`847`	`\| ty::ClauseKind::Projection(_)`
`848`	`848`	`\| ty::ClauseKind::ConstArgHasType(_, _)`
`849`	`849`	`\| ty::ClauseKind::WellFormed(_)`
`850`		`- \| ty::ClauseKind::ConstEvaluatable(_)`
`851`		`- \| ty::ClauseKind::TypeWellFormedFromEnv(_) => None,`
	`850`	`+ \| ty::ClauseKind::ConstEvaluatable(_) => None,`
`852`	`851`	`}`
`853`	`852`	`});`
`854`	`853`
Original file line number	Diff line number	Diff line change
`@@ -31,8 +31,7 @@ pub fn explicit_outlives_bounds<'tcx>(`
`31`	`31`	`\| ty::ClauseKind::Projection(_)`
`32`	`32`	`\| ty::ClauseKind::ConstArgHasType(_, _)`
`33`	`33`	`\| ty::ClauseKind::WellFormed(_)`
`34`		`- \| ty::ClauseKind::ConstEvaluatable(_)`
`35`		`- \| ty::ClauseKind::TypeWellFormedFromEnv(_) => None,`
	`34`	`+ \| ty::ClauseKind::ConstEvaluatable(_) => None,`
`36`	`35`	`})`
`37`	`36`	`}`
`38`	`37`
Original file line number	Diff line number	Diff line change
`@@ -554,8 +554,7 @@ impl<'tcx> Predicate<'tcx> {`
`554`	`554`	`\| PredicateKind::Coerce(_)`
`555`	`555`	`\| PredicateKind::Clause(ClauseKind::ConstEvaluatable(_))`
`556`	`556`	`\| PredicateKind::ConstEquate(_, _)`
`557`		`- \| PredicateKind::Ambiguous`
`558`		`- \| PredicateKind::Clause(ClauseKind::TypeWellFormedFromEnv(_)) => true,`
	`557`	`+ \| PredicateKind::Ambiguous => true,`
`559`	`558`	`}`
`560`	`559`	`}`
`561`	`560`	`}`
`@@ -661,11 +660,6 @@ pub enum ClauseKind<'tcx> {`
`661`	`660`
`662`	`661`	`/// Constant initializer must evaluate successfully.`
`663`	`662`	`ConstEvaluatable(ty::Const<'tcx>),`
`664`		`-`
`665`		`- /// Represents a type found in the environment that we can use for implied bounds.`
`666`		`- ///`
`667`		`- /// Only used for Chalk.`
`668`		`- TypeWellFormedFromEnv(Ty<'tcx>),`
`669`	`663`	`}`
`670`	`664`
`671`	`665`	`#[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]`
`@@ -1424,8 +1418,7 @@ impl<'tcx> Predicate<'tcx> {`
`1424`	`1418`	`\| PredicateKind::Clause(ClauseKind::TypeOutlives(..))`
`1425`	`1419`	`\| PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))`
`1426`	`1420`	`\| PredicateKind::ConstEquate(..)`
`1427`		`- \| PredicateKind::Ambiguous`
`1428`		`- \| PredicateKind::Clause(ClauseKind::TypeWellFormedFromEnv(..)) => None,`
	`1421`	`+ \| PredicateKind::Ambiguous => None,`
`1429`	`1422`	`}`
`1430`	`1423`	`}`
`1431`	`1424`
`@@ -1445,8 +1438,7 @@ impl<'tcx> Predicate<'tcx> {`
`1445`	`1438`	`\| PredicateKind::Clause(ClauseKind::TypeOutlives(..))`
`1446`	`1439`	`\| PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))`
`1447`	`1440`	`\| PredicateKind::ConstEquate(..)`
`1448`		`- \| PredicateKind::Ambiguous`
`1449`		`- \| PredicateKind::Clause(ClauseKind::TypeWellFormedFromEnv(..)) => None,`
	`1441`	`+ \| PredicateKind::Ambiguous => None,`
`1450`	`1442`	`}`
`1451`	`1443`	`}`
`1452`	`1444`
`@@ -1466,8 +1458,7 @@ impl<'tcx> Predicate<'tcx> {`
`1466`	`1458`	`\| PredicateKind::ClosureKind(..)`
`1467`	`1459`	`\| PredicateKind::Clause(ClauseKind::ConstEvaluatable(..))`
`1468`	`1460`	`\| PredicateKind::ConstEquate(..)`
`1469`		`- \| PredicateKind::Ambiguous`
`1470`		`- \| PredicateKind::Clause(ClauseKind::TypeWellFormedFromEnv(..)) => None,`
	`1461`	`+ \| PredicateKind::Ambiguous => None,`
`1471`	`1462`	`}`
`1472`	`1463`	`}`
`1473`	`1464`