Elide lifetimes in 'core'.

core/http/src/lib.rs

@@ -5,7 +5,6 @@
 #![recursion_limit="512"]
 
 #![warn(rust_2018_idioms)]
-#![warn(single_use_lifetimes)]
 
 //! Types that map to concepts in HTTP.
 //!

core/lib/src/config/toml_ext.rs

@@ -83,7 +83,7 @@ pub fn parse_simple_toml_value(mut input: &str) -> StdResult<Value, String> {
 /// `Display`. This is used to log config values at initialization.
 crate struct LoggedValue<'a>(pub &'a Value);
 
-impl<'a> fmt::Display for LoggedValue<'a> {
+impl fmt::Display for LoggedValue<'_> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use crate::config::Value::*;

core/lib/src/data/from_data.rs

@@ -9,7 +9,7 @@ use crate::data::Data;
 /// Type alias for the `Outcome` of a `FromData` conversion.
 pub type Outcome<S, E> = outcome::Outcome<S, (Status, E), Data>;
 
-impl<'a, S, E> IntoOutcome<S, (Status, E), Data> for Result<S, E> {
+impl<S, E> IntoOutcome<S, (Status, E), Data> for Result<S, E> {
     type Failure = Status;
     type Forward = Data;
 

core/lib/src/fairing/mod.rs

@@ -308,10 +308,10 @@ pub use self::info_kind::{Info, Kind};
 /// pub struct StartTime(pub SystemTime);
 ///
 /// // Allows a route to access the time a request was initiated.
-/// impl<'a, 'r> FromRequest<'a, 'r> for StartTime {
+/// impl FromRequest<'_, '_> for StartTime {
 ///     type Error = ();
 ///
-///     fn from_request(request: &'a Request<'r>) -> request::Outcome<StartTime, ()> {
+///     fn from_request(request: &Request<'_>) -> request::Outcome<StartTime, ()> {
 ///         match *request.local_cache(|| TimerStart(None)) {
 ///             TimerStart(Some(time)) => Outcome::Success(StartTime(time)),
 ///             TimerStart(None) => Outcome::Failure((Status::InternalServerError, ())),

core/lib/src/local/request.rs

@@ -434,7 +434,7 @@ impl<'c> LocalRequest<'c> {
     }
 }
 
-impl<'c> fmt::Debug for LocalRequest<'c> {
+impl fmt::Debug for LocalRequest<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.request, f)
     }
@@ -468,7 +468,7 @@ impl<'c> DerefMut for LocalResponse<'c> {
     }
 }
 
-impl<'c> fmt::Debug for LocalResponse<'c> {
+impl fmt::Debug for LocalResponse<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.response, f)
     }

core/lib/src/request/form/form_items.rs

@@ -211,7 +211,7 @@ impl<'f> FormItem<'f> {
     }
 }
 
-impl<'f> FormItems<'f> {
+impl FormItems<'_> {
     /// Returns `true` if the form string was parsed to completion. Returns
     /// `false` otherwise. All valid form strings will parse to completion,
     /// while invalid form strings will not.

core/lib/src/request/from_request.rs

@@ -186,10 +186,10 @@ impl<S, E> IntoOutcome<S, (Status, E), ()> for Result<S, E> {
 ///     Invalid,
 /// }
 ///
-/// impl<'a, 'r> FromRequest<'a, 'r> for ApiKey {
+/// impl FromRequest<'_, '_> for ApiKey {
 ///     type Error = ApiKeyError;
 ///
-///     fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+///     fn from_request(request: &Request<'_>) -> request::Outcome<Self, Self::Error> {
 ///         let keys: Vec<_> = request.headers().get("x-api-key").collect();
 ///         match keys.len() {
 ///             0 => Outcome::Failure((Status::BadRequest, ApiKeyError::Missing)),
@@ -232,19 +232,19 @@ impl<S, E> IntoOutcome<S, (Status, E), ()> for Result<S, E> {
 /// #         Ok(User { id, is_admin: false })
 /// #     }
 /// # }
-/// # impl<'a, 'r> FromRequest<'a, 'r> for Database {
+/// # impl FromRequest<'_, '_> for Database {
 /// #     type Error = ();
-/// #     fn from_request(request: &'a Request<'r>) -> request::Outcome<Database, ()> {
+/// #     fn from_request(request: &Request<'_>) -> request::Outcome<Database, ()> {
 /// #         Outcome::Success(Database)
 /// #     }
 /// # }
 /// #
 /// # struct Admin { user: User }
 /// #
-/// impl<'a, 'r> FromRequest<'a, 'r> for User {
+/// impl FromRequest<'_, '_> for User {
 ///     type Error = ();
 ///
-///     fn from_request(request: &'a Request<'r>) -> request::Outcome<User, ()> {
+///     fn from_request(request: &Request<'_>) -> request::Outcome<User, ()> {
 ///         let db = request.guard::<Database>()?;
 ///         request.cookies()
 ///             .get_private("user_id")
@@ -254,10 +254,10 @@ impl<S, E> IntoOutcome<S, (Status, E), ()> for Result<S, E> {
 ///     }
 /// }
 ///
-/// impl<'a, 'r> FromRequest<'a, 'r> for Admin {
+/// impl FromRequest<'_, '_> for Admin {
 ///     type Error = ();
 ///
-///     fn from_request(request: &'a Request<'r>) -> request::Outcome<Admin, ()> {
+///     fn from_request(request: &Request<'_>) -> request::Outcome<Admin, ()> {
 ///         // This will unconditionally query the database!
 ///         let user = request.guard::<User>()?;
 ///
@@ -296,19 +296,19 @@ impl<S, E> IntoOutcome<S, (Status, E), ()> for Result<S, E> {
 /// #         Ok(User { id, is_admin: false })
 /// #     }
 /// # }
-/// # impl<'a, 'r> FromRequest<'a, 'r> for Database {
+/// # impl FromRequest<'_, '_> for Database {
 /// #     type Error = ();
-/// #     fn from_request(request: &'a Request<'r>) -> request::Outcome<Database, ()> {
+/// #     fn from_request(request: &Request<'_>) -> request::Outcome<Database, ()> {
 /// #         Outcome::Success(Database)
 /// #     }
 /// # }
 /// #
 /// # struct Admin<'a> { user: &'a User }
 /// #
-/// impl<'a, 'r> FromRequest<'a, 'r> for &'a User {
+/// impl<'a> FromRequest<'a, '_> for &'a User {
 ///     type Error = !;
 ///
-///     fn from_request(request: &'a Request<'r>) -> request::Outcome<&'a User, !> {
+///     fn from_request(request: &'a Request<'_>) -> request::Outcome<&'a User, !> {
 ///         // This closure will execute at most once per request, regardless of
 ///         // the number of times the `User` guard is executed.
 ///         let user_result = request.local_cache(|| {
@@ -323,10 +323,10 @@ impl<S, E> IntoOutcome<S, (Status, E), ()> for Result<S, E> {
 ///     }
 /// }
 ///
-/// impl<'a, 'r> FromRequest<'a, 'r> for Admin<'a> {
+/// impl<'a> FromRequest<'a, '_> for Admin<'a> {
 ///     type Error = !;
 ///
-///     fn from_request(request: &'a Request<'r>) -> request::Outcome<Admin<'a>, !> {
+///     fn from_request(request: &'a Request<'_>) -> request::Outcome<Admin<'a>, !> {
 ///         let user = request.guard::<&User>()?;
 ///
 ///         if user.is_admin {
@@ -357,67 +357,67 @@ pub trait FromRequest<'a, 'r>: Sized {
     fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error>;
 }
 
-impl<'a, 'r> FromRequest<'a, 'r> for Method {
+impl FromRequest<'_, '_> for Method {
     type Error = !;
 
-    fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error> {
+    fn from_request(request: &Request<'_>) -> Outcome<Self, Self::Error> {
         Success(request.method())
     }
 }
 
-impl<'a, 'r> FromRequest<'a, 'r> for &'a Origin<'a> {
+impl<'a> FromRequest<'a, '_> for &'a Origin<'a> {
     type Error = !;
 
-    fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error> {
+    fn from_request(request: &'a Request<'_>) -> Outcome<Self, Self::Error> {
         Success(request.uri())
     }
 }
 
-impl<'a, 'r> FromRequest<'a, 'r> for &'r Route {
+impl<'r> FromRequest<'_, 'r> for &'r Route {
     type Error = !;
 
-    fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error> {
+    fn from_request(request: &Request<'r>) -> Outcome<Self, Self::Error> {
         match request.route() {
             Some(route) => Success(route),
             None => Forward(())
         }
     }
 }
 
-impl<'a, 'r> FromRequest<'a, 'r> for Cookies<'a> {
+impl<'a> FromRequest<'a, '_> for Cookies<'a> {
     type Error = !;
 
-    fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error> {
+    fn from_request(request: &'a Request<'_>) -> Outcome<Self, Self::Error> {
         Success(request.cookies())
     }
 }
 
-impl<'a, 'r> FromRequest<'a, 'r> for &'a Accept {
+impl<'a> FromRequest<'a, '_> for &'a Accept {
     type Error = !;
 
-    fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error> {
+    fn from_request(request: &'a Request<'_>) -> Outcome<Self, Self::Error> {
         match request.accept() {
             Some(accept) => Success(accept),
             None => Forward(())
         }
     }
 }
 
-impl<'a, 'r> FromRequest<'a, 'r> for &'a ContentType {
+impl<'a> FromRequest<'a, '_> for &'a ContentType {
     type Error = !;
 
-    fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error> {
+    fn from_request(request: &'a Request<'_>) -> Outcome<Self, Self::Error> {
         match request.content_type() {
             Some(content_type) => Success(content_type),
             None => Forward(())
         }
     }
 }
 
-impl<'a, 'r> FromRequest<'a, 'r> for SocketAddr {
+impl FromRequest<'_, '_> for SocketAddr {
     type Error = !;
 
-    fn from_request(request: &'a Request<'r>) -> Outcome<Self, Self::Error> {
+    fn from_request(request: &Request<'_>) -> Outcome<Self, Self::Error> {
         match request.remote() {
             Some(addr) => Success(addr),
             None => Forward(())

core/lib/src/request/param.rs

@@ -322,10 +322,10 @@ impl<'a> FromSegments<'a> for Segments<'a> {
 /// As a result of these conditions, a `PathBuf` derived via `FromSegments` is
 /// safe to interpolate within, or use as a suffix of, a path without additional
 /// checks.
-impl<'a> FromSegments<'a> for PathBuf {
+impl FromSegments<'_> for PathBuf {
     type Error = SegmentError;
 
-    fn from_segments(segments: Segments<'a>) -> Result<PathBuf, SegmentError> {
+    fn from_segments(segments: Segments<'_>) -> Result<PathBuf, SegmentError> {
         segments.into_path_buf(false)
     }
 }

core/lib/src/request/query.rs

@@ -36,7 +36,7 @@ use crate::request::{FormItems, FormItem, Form, LenientForm, FromForm};
 /// # struct MyType;
 /// # type Result = std::result::Result<MyType, ()>;
 /// #
-/// # impl<'q> FromQuery<'q> for MyType {
+/// # impl FromQuery<'_> for MyType {
 /// #    type Error = ();
 /// #
 /// fn from_query(query: Query) -> Result {

core/lib/src/request/request.rs

@@ -842,7 +842,7 @@ impl<'r> Request<'r> {
     }
 }
 
-impl<'r> fmt::Debug for Request<'r> {
+impl fmt::Debug for Request<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("Request")
             .field("method", &self.method)
@@ -853,7 +853,7 @@ impl<'r> fmt::Debug for Request<'r> {
     }
 }
 
-impl<'r> fmt::Display for Request<'r> {
+impl fmt::Display for Request<'_> {
     /// Pretty prints a Request. This is primarily used by Rocket's logging
     /// infrastructure.
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

core/lib/src/request/state.rs

@@ -70,10 +70,10 @@ use crate::http::Status;
 /// # struct MyConfig{ user_val: String };
 /// struct Item(String);
 ///
-/// impl<'a, 'r> FromRequest<'a, 'r> for Item {
+/// impl FromRequest<'_, '_> for Item {
 ///     type Error = ();
 ///
-///     fn from_request(request: &'a Request<'r>) -> request::Outcome<Item, ()> {
+///     fn from_request(request: &Request<'_>) -> request::Outcome<Item, ()> {
 ///         request.guard::<State<MyConfig>>()
 ///             .map(|my_config| Item(my_config.user_val.clone()))
 ///     }
@@ -165,11 +165,11 @@ impl<'r, T: Send + Sync + 'static> State<'r, T> {
     }
 }
 
-impl<'a, 'r, T: Send + Sync + 'static> FromRequest<'a, 'r> for State<'r, T> {
+impl<'r, T: Send + Sync + 'static> FromRequest<'_, 'r> for State<'r, T> {
     type Error = ();
 
     #[inline(always)]
-    fn from_request(req: &'a Request<'r>) -> request::Outcome<State<'r, T>, ()> {
+    fn from_request(req: &Request<'r>) -> request::Outcome<State<'r, T>, ()> {
         match req.state.managed.try_get::<T>() {
             Some(state) => Outcome::Success(State(state)),
             None => {
@@ -180,7 +180,7 @@ impl<'a, 'r, T: Send + Sync + 'static> FromRequest<'a, 'r> for State<'r, T> {
     }
 }
 
-impl<'r, T: Send + Sync + 'static> Deref for State<'r, T> {
+impl<T: Send + Sync + 'static> Deref for State<'_, T> {
     type Target = T;
 
     #[inline(always)]

core/lib/src/response/named_file.rs

@@ -78,8 +78,8 @@ impl NamedFile {
 /// recognized. See [`ContentType::from_extension()`] for more information. If
 /// you would like to stream a file with a different Content-Type than that
 /// implied by its extension, use a [`File`] directly.
-impl<'r> Responder<'r> for NamedFile {
-    fn respond_to(self, req: &Request<'_>) -> response::Result<'r> {
+impl Responder<'_> for NamedFile {
+    fn respond_to(self, req: &Request<'_>) -> response::Result<'static> {
         let mut response = self.1.respond_to(req)?;
         if let Some(ext) = self.0.extension() {
             if let Some(ct) = ContentType::from_extension(&ext.to_string_lossy()) {
@@ -131,7 +131,7 @@ impl io::Seek for NamedFile {
     }
 }
 
-impl<'a> io::Read for &'a NamedFile {
+impl io::Read for &NamedFile {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.file().read(buf)
     }
@@ -141,7 +141,7 @@ impl<'a> io::Read for &'a NamedFile {
     }
 }
 
-impl<'a> io::Write for &'a NamedFile {
+impl io::Write for &NamedFile {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.file().write(buf)
     }
@@ -151,7 +151,7 @@ impl<'a> io::Write for &'a NamedFile {
     }
 }
 
-impl<'a> io::Seek for &'a NamedFile {
+impl io::Seek for &NamedFile {
     fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
         self.file().seek(pos)
     }

core/lib/src/response/redirect.rs

@@ -147,7 +147,7 @@ impl Redirect {
 /// the `Location` header field. The body of the response is empty. If the URI
 /// value used to create the `Responder` is an invalid URI, an error of
 /// `Status::InternalServerError` is returned.
-impl<'a> Responder<'a> for Redirect {
+impl Responder<'_> for Redirect {
     fn respond_to(self, _: &Request<'_>) -> Result<Response<'static>, Status> {
         if let Some(uri) = self.1 {
             Response::build()