Adding upstream version 1.68.2+dfsg1.upstream/1.68.2+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 349 insertions, 0 deletions

diff --git a/vendor/chalk-ir-0.87.0/src/visit/binder_impls.rs b/vendor/chalk-ir-0.87.0/src/visit/binder_impls.rs
new file mode 100644
index 000000000..709f99044
--- /dev/null
+++ b/vendor/chalk-ir-0.87.0/src/visit/binder_impls.rs
@@ -0,0 +1,47 @@
+//! This module contains impls of `TypeVisitable` for those types that
+//! introduce binders.
+//!
+//! The more interesting impls of `TypeVisitable` remain in the `visit` module.
+
+use crate::interner::HasInterner;
+use crate::{
+    Binders, Canonical, ControlFlow, DebruijnIndex, FnPointer, Interner, TypeVisitable, TypeVisitor,
+};
+
+impl<I: Interner> TypeVisitable<I> for FnPointer<I> {
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        self.substitution
+            .visit_with(visitor, outer_binder.shifted_in())
+    }
+}
+
+impl<T, I: Interner> TypeVisitable<I> for Binders<T>
+where
+    T: HasInterner + TypeVisitable<I>,
+{
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        self.value.visit_with(visitor, outer_binder.shifted_in())
+    }
+}
+
+impl<I, T> TypeVisitable<I> for Canonical<T>
+where
+    I: Interner,
+    T: HasInterner<Interner = I> + TypeVisitable<I>,
+{
+    fn visit_with<B>(
+        &self,
+        visitor: &mut dyn TypeVisitor<I, BreakTy = B>,
+        outer_binder: DebruijnIndex,
+    ) -> ControlFlow<B> {
+        self.value.visit_with(visitor, outer_binder.shifted_in())
+    }
+}
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(())
+    }
+}
diff --git a/vendor/chalk-ir-0.87.0/src/visit/visitors.rs b/vendor/chalk-ir-0.87.0/src/visit/visitors.rs
new file mode 100644
index 000000000..51c087840
--- /dev/null
+++ b/vendor/chalk-ir-0.87.0/src/visit/visitors.rs
@@ -0,0 +1,41 @@
+//! TypeVisitor helpers
+
+use crate::{BoundVar, ControlFlow, DebruijnIndex, Interner, TypeVisitable, TypeVisitor};
+
+/// TypeVisitor extensions.
+pub trait VisitExt<I: Interner>: TypeVisitable<I> {
+    /// Check whether there are free (non-bound) variables.
+    fn has_free_vars(&self, interner: I) -> bool {
+        let flow = self.visit_with(
+            &mut FindFreeVarsVisitor { interner },
+            DebruijnIndex::INNERMOST,
+        );
+        matches!(flow, ControlFlow::Break(_))
+    }
+}
+
+impl<T, I: Interner> VisitExt<I> for T where T: TypeVisitable<I> {}
+
+struct FindFreeVarsVisitor<I: Interner> {
+    interner: I,
+}
+
+impl<I: Interner> TypeVisitor<I> for FindFreeVarsVisitor<I> {
+    type BreakTy = ();
+
+    fn as_dyn(&mut self) -> &mut dyn TypeVisitor<I, BreakTy = Self::BreakTy> {
+        self
+    }
+
+    fn interner(&self) -> I {
+        self.interner
+    }
+
+    fn visit_free_var(
+        &mut self,
+        _bound_var: BoundVar,
+        _outer_binder: DebruijnIndex,
+    ) -> ControlFlow<()> {
+        ControlFlow::Break(())
+    }
+}