vendor/chalk-ir-0.25.0/src/visit/boring_impls.rs

   1 //! This module contains "rote and uninteresting" impls of `Visit` for
   2 //! various types. In general, we prefer to derive `Visit`, but
   3 //! sometimes that doesn't work for whatever reason.
   4 //!
   5 //! The more interesting impls of `Visit` remain in the `visit` module.
   6
   7 use crate::{
   8     AdtId, AssocTypeId, ClausePriority, ClosureId, Constraints, DebruijnIndex, FloatTy, FnDefId,
   9     GenericArg, Goals, ImplId, IntTy, Interner, Mutability, OpaqueTyId, PlaceholderIndex,
  10     ProgramClause, ProgramClauses, QuantifiedWhereClauses, QuantifierKind, Safety, Scalar,
  11     Substitution, SuperVisit, TraitId, UintTy, UniverseIndex, Visit, VisitResult, Visitor,
  12 };
  13 use std::{marker::PhantomData, sync::Arc};
  14
  15 /// Convenience function to visit all the items in the iterator it.
  16 pub fn visit_iter<'i, T, I, R>(
  17     it: impl Iterator<Item = T>,
  18     visitor: &mut dyn Visitor<'i, I, Result = R>,
  19     outer_binder: DebruijnIndex,
  20 ) -> R
  21 where
  22     T: Visit<I>,
  23     I: 'i + Interner,
  24     R: VisitResult,
  25 {
  26     let mut result = R::new();
  27     for e in it {
  28         result = result.combine(e.visit_with(visitor, outer_binder));
  29         if result.return_early() {
  30             return result;
  31         }
  32     }
  33     result
  34 }
  35
  36 impl<T: Visit<I>, I: Interner> Visit<I> for &T {
  37     fn visit_with<'i, R: VisitResult>(
  38         &self,
  39         visitor: &mut dyn Visitor<'i, I, Result = R>,
  40         outer_binder: DebruijnIndex,
  41     ) -> R
  42     where
  43         I: 'i,
  44     {
  45         T::visit_with(self, visitor, outer_binder)
  46     }
  47 }
  48
  49 impl<T: Visit<I>, I: Interner> Visit<I> for Vec<T> {
  50     fn visit_with<'i, R: VisitResult>(
  51         &self,
  52         visitor: &mut dyn Visitor<'i, I, Result = R>,
  53         outer_binder: DebruijnIndex,
  54     ) -> R
  55     where
  56         I: 'i,
  57     {
  58         visit_iter(self.iter(), visitor, outer_binder)
  59     }
  60 }
  61
  62 impl<T: Visit<I>, I: Interner> Visit<I> for &[T] {
  63     fn visit_with<'i, R: VisitResult>(
  64         &self,
  65         visitor: &mut dyn Visitor<'i, I, Result = R>,
  66         outer_binder: DebruijnIndex,
  67     ) -> R
  68     where
  69         I: 'i,
  70     {
  71         visit_iter(self.iter(), visitor, outer_binder)
  72     }
  73 }
  74
  75 impl<T: Visit<I>, I: Interner> Visit<I> for Box<T> {
  76     fn visit_with<'i, R: VisitResult>(
  77         &self,
  78         visitor: &mut dyn Visitor<'i, I, Result = R>,
  79         outer_binder: DebruijnIndex,
  80     ) -> R
  81     where
  82         I: 'i,
  83     {
  84         T::visit_with(self, visitor, outer_binder)
  85     }
  86 }
  87
  88 impl<T: Visit<I>, I: Interner> Visit<I> for Arc<T> {
  89     fn visit_with<'i, R: VisitResult>(
  90         &self,
  91         visitor: &mut dyn Visitor<'i, I, Result = R>,
  92         outer_binder: DebruijnIndex,
  93     ) -> R
  94     where
  95         I: 'i,
  96     {
  97         T::visit_with(self, visitor, outer_binder)
  98     }
  99 }
 100
 101 macro_rules! tuple_visit {
 102     ($($n:ident),*) => {
 103         impl<$($n: Visit<I>,)* I: Interner> Visit<I> for ($($n,)*) {
 104             fn visit_with<'i, R: VisitResult>(&self, visitor: &mut dyn Visitor<'i, I, Result = R>, outer_binder: DebruijnIndex) -> R where I: 'i
 105             {
 106                 #[allow(non_snake_case)]
 107                 let &($(ref $n),*) = self;
 108                 let mut result = R::new();
 109                 $(
 110                     result = result.combine($n.visit_with(visitor, outer_binder));
 111                     if result.return_early() { return result; }
 112                 )*
 113                 result
 114             }
 115         }
 116     }
 117 }
 118
 119 tuple_visit!(A, B);
 120 tuple_visit!(A, B, C);
 121 tuple_visit!(A, B, C, D);
 122 tuple_visit!(A, B, C, D, E);
 123
 124 impl<T: Visit<I>, I: Interner> Visit<I> for Option<T> {
 125     fn visit_with<'i, R: VisitResult>(
 126         &self,
 127         visitor: &mut dyn Visitor<'i, I, Result = R>,
 128         outer_binder: DebruijnIndex,
 129     ) -> R
 130     where
 131         I: 'i,
 132     {
 133         match self {
 134             Some(e) => e.visit_with(visitor, outer_binder),
 135             None => R::new(),
 136         }
 137     }
 138 }
 139
 140 impl<I: Interner> Visit<I> for GenericArg<I> {
 141     fn visit_with<'i, R: VisitResult>(
 142         &self,
 143         visitor: &mut dyn Visitor<'i, I, Result = R>,
 144         outer_binder: DebruijnIndex,
 145     ) -> R
 146     where
 147         I: 'i,
 148     {
 149         let interner = visitor.interner();
 150         self.data(interner).visit_with(visitor, outer_binder)
 151     }
 152 }
 153
 154 impl<I: Interner> Visit<I> for Substitution<I> {
 155     fn visit_with<'i, R: VisitResult>(
 156         &self,
 157         visitor: &mut dyn Visitor<'i, I, Result = R>,
 158         outer_binder: DebruijnIndex,
 159     ) -> R
 160     where
 161         I: 'i,
 162     {
 163         let interner = visitor.interner();
 164         visit_iter(self.iter(interner), visitor, outer_binder)
 165     }
 166 }
 167
 168 impl<I: Interner> Visit<I> for Goals<I> {
 169     fn visit_with<'i, R: VisitResult>(
 170         &self,
 171         visitor: &mut dyn Visitor<'i, I, Result = R>,
 172         outer_binder: DebruijnIndex,
 173     ) -> R
 174     where
 175         I: 'i,
 176     {
 177         let interner = visitor.interner();
 178         visit_iter(self.iter(interner), visitor, outer_binder)
 179     }
 180 }
 181
 182 #[doc(hidden)]
 183 #[macro_export]
 184 macro_rules! const_visit {
 185     ($t:ty) => {
 186         impl<I: Interner> $crate::visit::Visit<I> for $t {
 187             fn visit_with<'i, R: VisitResult>(
 188                 &self,
 189                 _visitor: &mut dyn ($crate::visit::Visitor<'i, I, Result = R>),
 190                 _outer_binder: DebruijnIndex,
 191             ) -> R
 192             where
 193                 I: 'i,
 194             {
 195                 R::new()
 196             }
 197         }
 198     };
 199 }
 200
 201 const_visit!(bool);
 202 const_visit!(usize);
 203 const_visit!(UniverseIndex);
 204 const_visit!(PlaceholderIndex);
 205 const_visit!(QuantifierKind);
 206 const_visit!(DebruijnIndex);
 207 const_visit!(ClausePriority);
 208 const_visit!(());
 209 const_visit!(Scalar);
 210 const_visit!(UintTy);
 211 const_visit!(IntTy);
 212 const_visit!(FloatTy);
 213 const_visit!(Mutability);
 214 const_visit!(Safety);
 215
 216 #[doc(hidden)]
 217 #[macro_export]
 218 macro_rules! id_visit {
 219     ($t:ident) => {
 220         impl<I: Interner> $crate::visit::Visit<I> for $t<I> {
 221             fn visit_with<'i, R: VisitResult>(
 222                 &self,
 223                 _visitor: &mut dyn ($crate::visit::Visitor<'i, I, Result = R>),
 224                 _outer_binder: DebruijnIndex,
 225             ) -> R
 226             where
 227                 I: 'i,
 228             {
 229                 R::new()
 230             }
 231         }
 232     };
 233 }
 234
 235 id_visit!(ImplId);
 236 id_visit!(AdtId);
 237 id_visit!(TraitId);
 238 id_visit!(OpaqueTyId);
 239 id_visit!(AssocTypeId);
 240 id_visit!(FnDefId);
 241 id_visit!(ClosureId);
 242
 243 impl<I: Interner> SuperVisit<I> for ProgramClause<I> {
 244     fn super_visit_with<'i, R: VisitResult>(
 245         &self,
 246         visitor: &mut dyn Visitor<'i, I, Result = R>,
 247         outer_binder: DebruijnIndex,
 248     ) -> R
 249     where
 250         I: 'i,
 251     {
 252         let interner = visitor.interner();
 253
 254         self.data(interner).0.visit_with(visitor, outer_binder)
 255     }
 256 }
 257
 258 impl<I: Interner> Visit<I> for ProgramClauses<I> {
 259     fn visit_with<'i, R: VisitResult>(
 260         &self,
 261         visitor: &mut dyn Visitor<'i, I, Result = R>,
 262         outer_binder: DebruijnIndex,
 263     ) -> R
 264     where
 265         I: 'i,
 266     {
 267         let interner = visitor.interner();
 268
 269         visit_iter(self.iter(interner), visitor, outer_binder)
 270     }
 271 }
 272
 273 impl<I: Interner> Visit<I> for Constraints<I> {
 274     fn visit_with<'i, R: VisitResult>(
 275         &self,
 276         visitor: &mut dyn Visitor<'i, I, Result = R>,
 277         outer_binder: DebruijnIndex,
 278     ) -> R
 279     where
 280         I: 'i,
 281     {
 282         let interner = visitor.interner();
 283
 284         visit_iter(self.iter(interner), visitor, outer_binder)
 285     }
 286 }
 287
 288 impl<I: Interner> Visit<I> for QuantifiedWhereClauses<I> {
 289     fn visit_with<'i, R: VisitResult>(
 290         &self,
 291         visitor: &mut dyn Visitor<'i, I, Result = R>,
 292         outer_binder: DebruijnIndex,
 293     ) -> R
 294     where
 295         I: 'i,
 296     {
 297         let interner = visitor.interner();
 298
 299         visit_iter(self.iter(interner), visitor, outer_binder)
 300     }
 301 }
 302
 303 impl<I: Interner> Visit<I> for PhantomData<I> {
 304     fn visit_with<'i, R: VisitResult>(
 305         &self,
 306         _visitor: &mut dyn Visitor<'i, I, Result = R>,
 307         _outer_binder: DebruijnIndex,
 308     ) -> R
 309     where
 310         I: 'i,
 311     {
 312         R::new()
 313     }
 314 }