Rename IsFirstInputType to InSelfTy

Author: fmease

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -12,7 +12,7 @@ use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::{Ident, Span};
 use rustc_trait_selection::traits::{
-    self, IsFirstInputType, OrphanCheckErr, OrphanCheckMode, UncoveredTyParams,
+    self, InSelfTy, OrphanCheckErr, OrphanCheckMode, UncoveredTyParams,
 };
 use tracing::{debug, instrument};
 
@@ -414,19 +414,16 @@ fn emit_orphan_check_error<'tcx>(
                 _ => errors::OnlyCurrentTraits::Arbitrary { span, note: () },
             });
 
-            for &(mut ty, is_target_ty) in &tys {
-                let span = if matches!(is_target_ty, IsFirstInputType::Yes) {
-                    // Point at `D<A>` in `impl<A, B> for C<B> in D<A>`
-                    impl_.self_ty.span
-                } else {
-                    // Point at `C<B>` in `impl<A, B> for C<B> in D<A>`
-                    hir_trait_ref.path.span
+            for &(mut ty, in_self_ty) in &tys {
+                // Given `impl<A, B> C<B> for D<A>`,
+                let span = match in_self_ty {
+                    InSelfTy::Yes => impl_.self_ty.span,     // point at `D<A>`.
+                    InSelfTy::No => hir_trait_ref.path.span, // point at `C<B>`.
                 };
 
                 ty = tcx.erase_regions(ty);
 
-                let is_foreign =
-                    !trait_ref.def_id.is_local() && matches!(is_target_ty, IsFirstInputType::No);
+                let is_foreign = !trait_ref.def_id.is_local() && matches!(in_self_ty, InSelfTy::No);
 
                 match *ty.kind() {
                     ty::Slice(_) => {

compiler/rustc_next_trait_solver/src/coherence.rs

@@ -96,26 +96,17 @@ pub fn trait_ref_is_local_or_fundamental<I: Interner>(tcx: I, trait_ref: ty::Tra
     trait_ref.def_id.is_local() || tcx.trait_is_fundamental(trait_ref.def_id)
 }
 
-TrivialTypeTraversalImpls! { IsFirstInputType, }
+TrivialTypeTraversalImpls! { InSelfTy }
 
 #[derive(Debug, Copy, Clone)]
-pub enum IsFirstInputType {
+pub enum InSelfTy {
     No,
     Yes,
 }
 
-impl From<bool> for IsFirstInputType {
-    fn from(b: bool) -> IsFirstInputType {
-        match b {
-            false => IsFirstInputType::No,
-            true => IsFirstInputType::Yes,
-        }
-    }
-}
-
 #[derive_where(Debug; I: Interner, T: Debug)]
 pub enum OrphanCheckErr<I: Interner, T> {
-    NonLocalInputType(Vec<(I::Ty, IsFirstInputType)>),
+    NonLocalInputType(Vec<(I::Ty, InSelfTy)>),
     UncoveredTyParams(UncoveredTyParams<I, T>),
 }
 
@@ -258,11 +249,11 @@ where
 struct OrphanChecker<'a, Infcx, I: Interner, F> {
     infcx: &'a Infcx,
     in_crate: InCrate,
-    in_self_ty: bool,
+    in_self_ty: InSelfTy,
     lazily_normalize_ty: F,
     /// Ignore orphan check failures and exclusively search for the first local type.
     search_first_local_ty: bool,
-    non_local_tys: Vec<(I::Ty, IsFirstInputType)>,
+    non_local_tys: Vec<(I::Ty, InSelfTy)>,
 }
 
 impl<'a, Infcx, I, F, E> OrphanChecker<'a, Infcx, I, F>
@@ -275,15 +266,15 @@ where
         OrphanChecker {
             infcx,
             in_crate,
-            in_self_ty: true,
+            in_self_ty: InSelfTy::Yes,
             lazily_normalize_ty,
             search_first_local_ty: false,
             non_local_tys: Vec::new(),
         }
     }
 
     fn found_non_local_ty(&mut self, t: I::Ty) -> ControlFlow<OrphanCheckEarlyExit<I, E>> {
-        self.non_local_tys.push((t, self.in_self_ty.into()));
+        self.non_local_tys.push((t, self.in_self_ty));
         ControlFlow::Continue(())
     }
 
@@ -449,7 +440,7 @@ where
         };
         // A bit of a hack, the `OrphanChecker` is only used to visit a `TraitRef`, so
         // the first type we visit is always the self type.
-        self.in_self_ty = false;
+        self.in_self_ty = InSelfTy::No;
         result
     }
 

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -41,7 +41,7 @@ use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument};
 
 pub use self::coherence::{
-    InCrate, IsFirstInputType, OrphanCheckErr, OrphanCheckMode, OverlapResult, UncoveredTyParams,
+    InCrate, InSelfTy, OrphanCheckErr, OrphanCheckMode, OverlapResult, UncoveredTyParams,
     add_placeholder_note, orphan_check_trait_ref, overlapping_impls,
 };
 pub use self::dyn_compatibility::{

compiler/rustc_type_ir/src/macros.rs

@@ -2,7 +2,7 @@
 /// allocated data** (i.e., don't need to be folded).
 #[macro_export]
 macro_rules! TrivialTypeTraversalImpls {
-    ($($ty:ty,)+) => {
+    ($($ty:ty),+ $(,)?) => {
         $(
             impl<I: $crate::Interner> $crate::TypeFoldable<I> for $ty {
                 fn try_fold_with<F: $crate::FallibleTypeFolder<I>>(