Refine Filter::or to propagate Never more eagerly

Closes #109

src/filter/and.rs

@@ -24,7 +24,7 @@ where
     U::Error: CombineRejection<T::Error>,
 {
     type Extract = <<<T::Extract as Tuple>::HList as Combine<<U::Extract as Tuple>::HList>>::Output as HList>::Tuple;
-    type Error = <U::Error as CombineRejection<T::Error>>::Rejection;
+    type Error = <U::Error as CombineRejection<T::Error>>::One;
     type Future = AndFuture<T, U>;
 
     fn filter(&self) -> Self::Future {
@@ -52,13 +52,12 @@ impl<T, U> Future for AndFuture<T, U>
 where
     T: Filter,
     U: Filter,
-    //T::Extract: Combine<U::Extract>,
     <T::Extract as Tuple>::HList: Combine<<U::Extract as Tuple>::HList> + Send,
     U::Error: CombineRejection<T::Error>,
 {
     type Output = Result<
             <<<T::Extract as Tuple>::HList as Combine<<U::Extract as Tuple>::HList>>::Output as HList>::Tuple,
-        <U::Error as CombineRejection<T::Error>>::Rejection>;
+        <U::Error as CombineRejection<T::Error>>::One>;
 
     #[project]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {

src/filter/and_then.rs

@@ -22,7 +22,7 @@ where
     <F::Output as TryFuture>::Error: CombineRejection<T::Error>,
 {
     type Extract = (<F::Output as TryFuture>::Ok,);
-    type Error = <<F::Output as TryFuture>::Error as CombineRejection<T::Error>>::Rejection;
+    type Error = <<F::Output as TryFuture>::Error as CombineRejection<T::Error>>::One;
     type Future = AndThenFuture<T, F>;
     #[inline]
     fn filter(&self) -> Self::Future {
@@ -66,7 +66,7 @@ where
     <F::Output as TryFuture>::Error: CombineRejection<T::Error>,
 {
     type Output = Result<(<F::Output as TryFuture>::Ok,),
-                         <<F::Output as TryFuture>::Error as CombineRejection<T::Error>>::Rejection>;
+                         <<F::Output as TryFuture>::Error as CombineRejection<T::Error>>::One>;
 
     #[project]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {

src/filter/or.rs

@@ -23,7 +23,7 @@ where
     U::Error: CombineRejection<T::Error>,
 {
     type Extract = (Either<T::Extract, U::Extract>,);
-    type Error = <U::Error as CombineRejection<T::Error>>::Rejection;
+    type Error = <U::Error as CombineRejection<T::Error>>::Combined;
     type Future = EitherFuture<T, U>;
 
     fn filter(&self) -> Self::Future {
@@ -65,7 +65,7 @@ where
     U: Filter,
     U::Error: CombineRejection<T::Error>,
 {
-    type Output = Result<(Either<T::Extract, U::Extract>,), <U::Error as CombineRejection<T::Error>>::Rejection>;
+    type Output = Result<(Either<T::Extract, U::Extract>,), <U::Error as CombineRejection<T::Error>>::Combined>;
 
     #[project]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {

src/filters/cors.rs

@@ -247,7 +247,7 @@ where
     F: Filter + Clone + Send + Sync + 'static,
     F::Extract: Reply,
     F::Error: CombineRejection<Rejection>,
-    <F::Error as CombineRejection<Rejection>>::Rejection: CombineRejection<Rejection>,
+    <F::Error as CombineRejection<Rejection>>::One: CombineRejection<Rejection>,
 {
     type Wrapped = CorsFilter<F>;
 
@@ -443,7 +443,7 @@ mod internal {
     {
         type Extract =
             One<Either<One<Preflight>, One<Either<One<Wrapped<F::Extract>>, F::Extract>>>>;
-        type Error = <F::Error as CombineRejection<Rejection>>::Rejection;
+        type Error = <F::Error as CombineRejection<Rejection>>::One;
         type Future = future::Either<
             future::Ready<Result<Self::Extract, Self::Error>>,
             WrappedFuture<F::Future>,
@@ -526,7 +526,7 @@ mod internal {
         F: TryFuture,
         F::Error: CombineRejection<Rejection>,
     {
-        type Output = Result<One<Either<One<Preflight>, One<Either<One<Wrapped<F::Ok>>, F::Ok>>>>, <F::Error as CombineRejection<Rejection>>::Rejection>;
+        type Output = Result<One<Either<One<Preflight>, One<Either<One<Wrapped<F::Ok>>, F::Ok>>>>, <F::Error as CombineRejection<Rejection>>::One>;
 
 
         fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {

src/reject.rs

@@ -657,6 +657,9 @@ mod sealed {
     use std::convert::Infallible;
     use std::fmt;
 
+    // This sealed trait exists to allow Filters to return either `Rejection`
+    // or `Never` (to be replaced with `!`). There are no other types that make
+    // sense, and so it is sealed.
     pub trait Reject: fmt::Debug + Send + Sync {
         fn status(&self) -> StatusCode;
         fn into_response(&self) -> crate::reply::Response;
@@ -669,16 +672,43 @@ mod sealed {
         fn _assert(_: &dyn Reject) {}
     }
 
+    // This weird trait is to allow optimizations of propagating when a
+    // rejection can *never* happen (currently with the `Never` type,
+    // eventually to be replaced with `!`).
+    //
+    // Using this trait means the `Never` gets propagated to chained filters,
+    // allowing LLVM to eliminate more code paths. Without it, such as just
+    // requiring that `Rejection::from(Never)` were used in those filters,
+    // would mean that links later in the chain may assume a rejection *could*
+    // happen, and no longer eliminate those branches.
     pub trait CombineRejection<E>: Send + Sized {
-        type Rejection: Reject + From<Self> + From<E> + Into<Rejection>;
-
-        fn combine(self, other: E) -> Self::Rejection;
+        /// The type that should be returned when only 1 of the two
+        /// "rejections" occurs.
+        ///
+        /// # For example:
+        ///
+        /// `warp::any().and(warp::path("foo")` has the following steps:
+        ///
+        /// 1. Since this is `and`, only **one** of the rejections will occur,
+        ///    and as soon as it does, it will be returned.
+        /// 2. `warp::any()` rejects with `Never`. So, it will never return `Never`.
+        /// 3. `warp::path()` rejects with `Rejection`. It may return `Rejection`.
+        ///
+        /// Thus, if the above filter rejects, it will definitely be `Rejection`.
+        type One: Reject + From<Self> + From<E> + Into<Rejection>;
+
+        /// The type that should be returned when both rejections occur,
+        /// and need to be combined.
+        type Combined: Reject;
+
+        fn combine(self, other: E) -> Self::Combined;
     }
 
     impl CombineRejection<Rejection> for Rejection {
-        type Rejection = Rejection;
+        type One = Rejection;
+        type Combined = Rejection;
 
-        fn combine(self, other: Rejection) -> Self::Rejection {
+        fn combine(self, other: Rejection) -> Self::Combined {
             let reason = match (self.reason, other.reason) {
                 (Reason::Other(left), Reason::Other(right)) => {
                     Reason::Other(Box::new(Rejections::Combined(left, right)))
@@ -696,25 +726,28 @@ mod sealed {
     }
 
     impl CombineRejection<Infallible> for Rejection {
-        type Rejection = Rejection;
+        type One = Rejection;
+        type Combined = Infallible;
 
-        fn combine(self, other: Infallible) -> Self::Rejection {
+        fn combine(self, other: Infallible) -> Self::Combined {
             match other {}
         }
     }
 
     impl CombineRejection<Rejection> for Infallible {
-        type Rejection = Rejection;
+        type One = Rejection;
+        type Combined = Infallible;
 
-        fn combine(self, _: Rejection) -> Self::Rejection {
+        fn combine(self, _: Rejection) -> Self::Combined {
             match self {}
         }
     }
 
-    impl CombineRejection<Infallible > for Infallible {
-        type Rejection = Infallible ;
+    impl CombineRejection<Infallible> for Infallible {
+        type One = Infallible;
+        type Combined = Infallible;
 
-        fn combine(self, _: Infallible) -> Self::Rejection {
+        fn combine(self, _: Infallible) -> Self::Combined {
             match self {}
         }
     }