1 files changed, 261 insertions, 0 deletions
diff --git a/vendor/chalk-ir-0.87.0/src/visit/boring_impls.rs b/vendor/chalk-ir-0.87.0/src/visit/boring_impls.rs
new file mode 100644
index 000000000..512d9ecd8
--- /dev/null
+++ b/vendor/chalk-ir-0.87.0/src/visit/boring_impls.rs
@@ -0,0 +1,261 @@
+//! This module contains "rote and uninteresting" impls of `TypeVisitable` for
+//! various types. In general, we prefer to derive `TypeVisitable`, but
+//! sometimes that doesn't work for whatever reason.
+//!
+//! The more interesting impls of `TypeVisitable` remain in the `visit` module.
+
+use crate::{
+    try_break, AdtId, AssocTypeId, ClausePriority, ClosureId, Constraints, ControlFlow,
+    DebruijnIndex, FloatTy, FnDefId, ForeignDefId, GeneratorId, GenericArg, Goals, ImplId, IntTy,
+    Interner, Mutability, OpaqueTyId, PlaceholderIndex, ProgramClause, ProgramClauses,
+    QuantifiedWhereClauses, QuantifierKind, Safety, Scalar, Substitution, TraitId,
+    TypeSuperVisitable, TypeVisitable, TypeVisitor, UintTy, UniverseIndex,
+};
+use std::{marker::PhantomData, sync::Arc};
+
+/// Convenience function to visit all the items in the iterator it.
+pub fn visit_iter<'i, T, I, B>(
+    it: impl Iterator<Item = T>,
+    visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+    outer_binder: DebruijnIndex,
+) -> ControlFlow<B>
+where
+    T: TypeVisitable<I>,
+    I: 'i + Interner,
+{
+    for e in it {
+        try_break!(e.visit_with(visitor, outer_binder));
+    }
+    ControlFlow::Continue(())
+}
+
+impl<T: TypeVisitable<I>, I: Interner> TypeVisitable<I> for &T {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        T::visit_with(self, visitor, outer_binder)
+    }
+}
+
+impl<T: TypeVisitable<I>, I: Interner> TypeVisitable<I> for Vec<T> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        visit_iter(self.iter(), visitor, outer_binder)
+    }
+}
+
+impl<T: TypeVisitable<I>, I: Interner> TypeVisitable<I> for &[T] {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        visit_iter(self.iter(), visitor, outer_binder)
+    }
+}
+
+impl<T: TypeVisitable<I>, I: Interner> TypeVisitable<I> for Box<T> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        T::visit_with(self, visitor, outer_binder)
+    }
+}
+
+impl<T: TypeVisitable<I>, I: Interner> TypeVisitable<I> for Arc<T> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        T::visit_with(self, visitor, outer_binder)
+    }
+}
+
+macro_rules! tuple_visit {
+    ($($n:ident),*) => {
+        impl<$($n: TypeVisitable<I>,)* I: Interner> TypeVisitable<I> for ($($n,)*) {
+            fn visit_with<BT>(&self, visitor: &mut dyn TypeVisitor<I, BreakTy = BT>, outer_binder: DebruijnIndex) -> ControlFlow<BT> {
+                #[allow(non_snake_case)]
+                let &($(ref $n),*) = self;
+                $(
+                    try_break!($n.visit_with(visitor, outer_binder));
+                )*
+                ControlFlow::Continue(())
+            }
+        }
+    }
+}
+
+tuple_visit!(A, B);
+tuple_visit!(A, B, C);
+tuple_visit!(A, B, C, D);
+tuple_visit!(A, B, C, D, E);
+
+impl<T: TypeVisitable<I>, I: Interner> TypeVisitable<I> for Option<T> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        match self {
+            Some(e) => e.visit_with(visitor, outer_binder),
+            None => ControlFlow::Continue(()),
+        }
+    }
+}
+
+impl<I: Interner> TypeVisitable<I> for GenericArg<I> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        let interner = visitor.interner();
+        self.data(interner).visit_with(visitor, outer_binder)
+    }
+}
+
+impl<I: Interner> TypeVisitable<I> for Substitution<I> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        let interner = visitor.interner();
+        visit_iter(self.iter(interner), visitor, outer_binder)
+    }
+}
+
+impl<I: Interner> TypeVisitable<I> for Goals<I> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        let interner = visitor.interner();
+        visit_iter(self.iter(interner), visitor, outer_binder)
+    }
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! const_visit {
+    ($t:ty) => {
+        impl<I: Interner> $crate::visit::TypeVisitable<I> for $t {
+            fn visit_with<B>(
+                &self,
+                _visitor: &mut dyn ($crate::visit::TypeVisitor<I, BreakTy = B>),
+                _outer_binder: DebruijnIndex,
+            ) -> ControlFlow<B> {
+                ControlFlow::Continue(())
+            }
+        }
+    };
+}
+
+const_visit!(bool);
+const_visit!(usize);
+const_visit!(UniverseIndex);
+const_visit!(PlaceholderIndex);
+const_visit!(QuantifierKind);
+const_visit!(DebruijnIndex);
+const_visit!(ClausePriority);
+const_visit!(());
+const_visit!(Scalar);
+const_visit!(UintTy);
+const_visit!(IntTy);
+const_visit!(FloatTy);
+const_visit!(Mutability);
+const_visit!(Safety);
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! id_visit {
+    ($t:ident) => {
+        impl<I: Interner> $crate::visit::TypeVisitable<I> for $t<I> {
+            fn visit_with<B>(
+                &self,
+                _visitor: &mut dyn ($crate::visit::TypeVisitor<I, BreakTy = B>),
+                _outer_binder: DebruijnIndex,
+            ) -> ControlFlow<B> {
+                ControlFlow::Continue(())
+            }
+        }
+    };
+}
+
+id_visit!(ImplId);
+id_visit!(AdtId);
+id_visit!(TraitId);
+id_visit!(OpaqueTyId);
+id_visit!(AssocTypeId);
+id_visit!(FnDefId);
+id_visit!(ClosureId);
+id_visit!(GeneratorId);
+id_visit!(ForeignDefId);
+
+impl<I: Interner> TypeSuperVisitable<I> for ProgramClause<I> {
+    fn super_visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        let interner = visitor.interner();
+
+        self.data(interner).0.visit_with(visitor, outer_binder)
+    }
+}
+
+impl<I: Interner> TypeVisitable<I> for ProgramClauses<I> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        let interner = visitor.interner();
+
+        visit_iter(self.iter(interner), visitor, outer_binder)
+    }
+}
+
+impl<I: Interner> TypeVisitable<I> for Constraints<I> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        let interner = visitor.interner();
+
+        visit_iter(self.iter(interner), visitor, outer_binder)
+    }
+}
+
+impl<I: Interner> TypeVisitable<I> for QuantifiedWhereClauses<I> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        let interner = visitor.interner();
+
+        visit_iter(self.iter(interner), visitor, outer_binder)
+    }
+}
+
+impl<I: Interner> TypeVisitable<I> for PhantomData<I> {
+    fn visit_with<B>(
+        &self,
+        _visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        _outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        ControlFlow::Continue(())
+    }
+}