Migrate codegen to Rust 2018.

core/codegen/Cargo.toml

@@ -10,6 +10,7 @@ readme = "../../README.md"
 keywords = ["rocket", "web", "framework", "code", "generation"]
 license = "MIT/Apache-2.0"
 build = "build.rs"
+edition = "2018"
 
 [lib]
 proc-macro = true

core/codegen/build.rs

@@ -1,8 +1,5 @@
 //! Ensures Rocket isn't compiled with an incompatible version of Rust.
 
-extern crate yansi;
-extern crate version_check;
-
 use yansi::{Paint, Color::{Red, Yellow, Blue}};
 
 // Specifies the minimum nightly version needed to compile Rocket.

core/codegen/src/attribute/catch.rs

@@ -1,11 +1,11 @@
 use proc_macro::{TokenStream, Span};
 use devise::{syn, Spanned, Result, FromMeta};
-use proc_macro2::TokenStream as TokenStream2;
+use crate::proc_macro2::TokenStream as TokenStream2;
 
-use http_codegen::Status;
-use syn_ext::{syn_to_diag, IdentExt, ReturnTypeExt};
+use crate::http_codegen::Status;
+use crate::syn_ext::{syn_to_diag, IdentExt, ReturnTypeExt};
 use self::syn::{Attribute, parse::Parser};
-use {CATCH_FN_PREFIX, CATCH_STRUCT_PREFIX};
+use crate::{CATCH_FN_PREFIX, CATCH_STRUCT_PREFIX};
 
 /// The raw, parsed `#[catch(code)]` attribute.
 #[derive(Debug, FromMeta)]

core/codegen/src/attribute/route.rs

@@ -1,15 +1,15 @@
 use proc_macro::{TokenStream, Span};
-use proc_macro2::TokenStream as TokenStream2;
+use crate::proc_macro2::TokenStream as TokenStream2;
 use devise::{syn, Spanned, SpanWrapped, Result, FromMeta, ext::TypeExt};
 use indexmap::IndexSet;
 
-use proc_macro_ext::{Diagnostics, StringLit};
-use syn_ext::{syn_to_diag, IdentExt};
+use crate::proc_macro_ext::{Diagnostics, StringLit};
+use crate::syn_ext::{syn_to_diag, IdentExt};
 use self::syn::{Attribute, parse::Parser};
 
-use http_codegen::{Method, MediaType, RoutePath, DataSegment, Optional};
-use attribute::segments::{Source, Kind, Segment};
-use {ROUTE_FN_PREFIX, ROUTE_STRUCT_PREFIX, URI_MACRO_PREFIX, ROCKET_PARAM_PREFIX};
+use crate::http_codegen::{Method, MediaType, RoutePath, DataSegment, Optional};
+use crate::attribute::segments::{Source, Kind, Segment};
+use crate::{ROUTE_FN_PREFIX, ROUTE_STRUCT_PREFIX, URI_MACRO_PREFIX, ROCKET_PARAM_PREFIX};
 
 /// The raw, parsed `#[route]` attribute.
 #[derive(Debug, FromMeta)]
@@ -425,7 +425,7 @@ fn complete_route(args: TokenStream2, input: TokenStream) -> Result<TokenStream>
 }
 
 fn incomplete_route(
-    method: ::http::Method,
+    method: crate::http::Method,
     args: TokenStream2,
     input: TokenStream
 ) -> Result<TokenStream> {
@@ -459,7 +459,7 @@ fn incomplete_route(
     codegen_route(parse_route(attribute, function)?)
 }
 
-pub fn route_attribute<M: Into<Option<::http::Method>>>(
+pub fn route_attribute<M: Into<Option<crate::http::Method>>>(
     method: M,
     args: TokenStream,
     input: TokenStream

core/codegen/src/attribute/segments.rs

@@ -3,11 +3,11 @@ use std::hash::{Hash, Hasher};
 use devise::syn;
 use proc_macro::{Span, Diagnostic};
 
-use http::uri::{UriPart, Path};
-use http::route::RouteSegment;
-use proc_macro_ext::{Diagnostics, StringLit, PResult, DResult};
+use crate::http::uri::{UriPart, Path};
+use crate::http::route::RouteSegment;
+use crate::proc_macro_ext::{Diagnostics, StringLit, PResult, DResult};
 
-crate use http::route::{Error, Kind, Source};
+crate use crate::http::route::{Error, Kind, Source};
 
 #[derive(Debug, Clone)]
 crate struct Segment {
@@ -19,7 +19,7 @@ crate struct Segment {
 }
 
 impl Segment {
-    fn from<P: UriPart>(segment: RouteSegment<P>, span: Span) -> Segment {
+    fn from<P: UriPart>(segment: RouteSegment<'_, P>, span: Span) -> Segment {
         let source = match P::DELIMITER {
             '/' => Source::Path,
             '&' => Source::Query,
@@ -31,7 +31,7 @@ impl Segment {
     }
 }
 
-impl<'a> From<&'a syn::Ident> for Segment {
+impl From<&syn::Ident> for Segment {
     fn from(ident: &syn::Ident) -> Segment {
         Segment {
             kind: Kind::Static,
@@ -76,7 +76,7 @@ fn into_diagnostic(
     segment: &str, // The segment that failed.
     source: &str,  // The haystack where `segment` can be found.
     span: Span,    // The `Span` of `Source`.
-    error: &Error,  // The error.
+    error: &Error<'_>,  // The error.
 ) -> Diagnostic {
     let seg_span = subspan(segment, source, span);
     match error {
@@ -116,7 +116,7 @@ fn into_diagnostic(
 }
 
 crate fn parse_data_segment(segment: &str, span: Span) -> PResult<Segment> {
-    <RouteSegment<Path>>::parse_one(segment)
+    <RouteSegment<'_, Path>>::parse_one(segment)
         .map(|segment| {
             let mut seg = Segment::from(segment, span);
             seg.source = Source::Data;
@@ -133,7 +133,7 @@ crate fn parse_segments<P: UriPart>(
     let mut segments = vec![];
     let mut diags = Diagnostics::new();
 
-    for result in <RouteSegment<P>>::parse_many(string) {
+    for result in <RouteSegment<'_, P>>::parse_many(string) {
         if let Err((segment_string, error)) = result {
             diags.push(into_diagnostic(segment_string, string, span, &error));
             if let Error::Trailing(..) = error {

core/codegen/src/bang/mod.rs

@@ -1,10 +1,10 @@
 use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
+use crate::proc_macro2::TokenStream as TokenStream2;
 
 use devise::{syn, Spanned, Result};
 use self::syn::{Path, punctuated::Punctuated, parse::Parser, token::Comma};
-use syn_ext::{IdentExt, syn_to_diag};
-use {ROUTE_STRUCT_PREFIX, CATCH_STRUCT_PREFIX};
+use crate::syn_ext::{IdentExt, syn_to_diag};
+use crate::{ROUTE_STRUCT_PREFIX, CATCH_STRUCT_PREFIX};
 
 mod uri;
 mod uri_parsing;

core/codegen/src/bang/uri.rs

@@ -1,17 +1,17 @@
 use std::fmt::Display;
 use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
+use crate::proc_macro2::TokenStream as TokenStream2;
 
 use devise::{syn, Result};
 use devise::syn::{Expr, Ident, Type, spanned::Spanned};
-use http::{uri::{Origin, Path, Query}, ext::IntoOwned};
-use http::route::{RouteSegment, Kind, Source};
+use crate::http::{uri::{Origin, Path, Query}, ext::IntoOwned};
+use crate::http::route::{RouteSegment, Kind, Source};
 
-use http_codegen::Optional;
-use syn_ext::{IdentExt, syn_to_diag};
-use bang::{prefix_last_segment, uri_parsing::*};
+use crate::http_codegen::Optional;
+use crate::syn_ext::{IdentExt, syn_to_diag};
+use crate::bang::{prefix_last_segment, uri_parsing::*};
 
-use URI_MACRO_PREFIX;
+use crate::URI_MACRO_PREFIX;
 
 macro_rules! p {
     (@go $num:expr, $singular:expr, $plural:expr) => (
@@ -122,7 +122,7 @@ fn add_binding(to: &mut Vec<TokenStream2>, ident: &Ident, ty: &Type, expr: &Expr
 }
 
 fn explode_path<'a, I: Iterator<Item = (&'a Ident, &'a Type, &'a Expr)>>(
-    uri: &Origin,
+    uri: &Origin<'_>,
     bindings: &mut Vec<TokenStream2>,
     mut items: I
 ) -> TokenStream2 {
@@ -132,7 +132,7 @@ fn explode_path<'a, I: Iterator<Item = (&'a Ident, &'a Type, &'a Expr)>>(
     }
 
     let uri_display = quote!(#uri_mod::UriDisplay<#uri_mod::Path>);
-    let dyn_exprs = <RouteSegment<Path>>::parse(uri).map(|segment| {
+    let dyn_exprs = <RouteSegment<'_, Path>>::parse(uri).map(|segment| {
         let segment = segment.expect("segment okay; prechecked on parse");
         match segment.kind {
             Kind::Static => {
@@ -151,7 +151,7 @@ fn explode_path<'a, I: Iterator<Item = (&'a Ident, &'a Type, &'a Expr)>>(
 }
 
 fn explode_query<'a, I: Iterator<Item = (&'a Ident, &'a Type, &'a ArgExpr)>>(
-    uri: &Origin,
+    uri: &Origin<'_>,
     bindings: &mut Vec<TokenStream2>,
     mut items: I
 ) -> Option<TokenStream2> {
@@ -162,7 +162,7 @@ fn explode_query<'a, I: Iterator<Item = (&'a Ident, &'a Type, &'a ArgExpr)>>(
 
     let query_arg = quote!(#uri_mod::UriQueryArgument);
     let uri_display = quote!(#uri_mod::UriDisplay<#uri_mod::Query>);
-    let dyn_exprs = <RouteSegment<Query>>::parse(uri)?.filter_map(|segment| {
+    let dyn_exprs = <RouteSegment<'_, Query>>::parse(uri)?.filter_map(|segment| {
         let segment = segment.expect("segment okay; prechecked on parse");
         if segment.kind == Kind::Static {
             let string = &segment.string;

core/codegen/src/bang/uri_parsing.rs

@@ -9,7 +9,7 @@ use self::syn::{Expr, Ident, LitStr, Path, Token, Type};
 use self::syn::parse::{self, Parse, ParseStream};
 use self::syn::punctuated::Punctuated;
 
-use http::{uri::Origin, ext::IntoOwned};
+use crate::http::{uri::Origin, ext::IntoOwned};
 use indexmap::IndexMap;
 
 #[derive(Debug)]
@@ -79,7 +79,7 @@ pub struct InternalUriParams {
 }
 
 impl Parse for ArgExpr {
-    fn parse(input: ParseStream) -> parse::Result<Self> {
+    fn parse(input: ParseStream<'_>) -> parse::Result<Self> {
         if input.peek(Token![_]) {
             return Ok(ArgExpr::Ignored(input.parse::<Token![_]>()?));
         }
@@ -89,7 +89,7 @@ impl Parse for ArgExpr {
 }
 
 impl Parse for Arg {
-    fn parse(input: ParseStream) -> parse::Result<Self> {
+    fn parse(input: ParseStream<'_>) -> parse::Result<Self> {
         let has_key = input.peek2(Token![=]);
         if has_key {
             let ident = input.parse::<Ident>()?;
@@ -109,7 +109,7 @@ fn err<T, S: AsRef<str>>(span: Span, s: S) -> parse::Result<T> {
 
 impl Parse for UriParams {
     // Parses the mount point, if any, route identifier, and arguments.
-    fn parse(input: ParseStream) -> parse::Result<Self> {
+    fn parse(input: ParseStream<'_>) -> parse::Result<Self> {
         if input.is_empty() {
             return Err(input.error("call to `uri!` cannot be empty"));
         }
@@ -176,7 +176,7 @@ impl Parse for UriParams {
 }
 
 impl Parse for FnArg {
-    fn parse(input: ParseStream) -> parse::Result<FnArg> {
+    fn parse(input: ParseStream<'_>) -> parse::Result<FnArg> {
         let ident = input.parse::<Ident>()?;
         input.parse::<Token![:]>()?;
         let mut ty = input.parse::<Type>()?;
@@ -186,7 +186,7 @@ impl Parse for FnArg {
 }
 
 impl Parse for InternalUriParams {
-    fn parse(input: ParseStream) -> parse::Result<InternalUriParams> {
+    fn parse(input: ParseStream<'_>) -> parse::Result<InternalUriParams> {
         let route_uri_str = input.parse::<LitStr>()?;
         input.parse::<Token![,]>()?;
 
@@ -215,7 +215,7 @@ impl InternalUriParams {
             .join(", ")
     }
 
-    pub fn validate(&self) -> Validation {
+    pub fn validate(&self) -> Validation<'_> {
         let args = &self.uri_params.arguments;
         match args {
             Args::Unnamed(inner) => {

core/codegen/src/derive/from_form.rs

@@ -23,7 +23,7 @@ fn is_valid_field_name(s: &str) -> bool {
 }
 
 impl FromMeta for FormField {
-    fn from_meta(meta: MetaItem) -> Result<Self> {
+    fn from_meta(meta: MetaItem<'_>) -> Result<Self> {
         let string = String::from_meta(meta)?;
         if !is_valid_field_name(&string) {
             return Err(meta.value_span().error("invalid form field name"));
@@ -33,7 +33,7 @@ impl FromMeta for FormField {
     }
 }
 
-fn validate_struct(gen: &DeriveGenerator, data: Struct) -> Result<()> {
+fn validate_struct(gen: &DeriveGenerator, data: Struct<'_>) -> Result<()> {
     if data.fields().is_empty() {
         return Err(gen.input.span().error("at least one field is required"));
     }

core/codegen/src/derive/responder.rs

@@ -3,7 +3,7 @@ use proc_macro::TokenStream;
 use devise::{*, ext::TypeExt};
 use devise::proc_macro2::TokenStream as TokenStream2;
 
-use http_codegen::{ContentType, Status};
+use crate::http_codegen::{ContentType, Status};
 
 #[derive(Default, FromMeta)]
 struct ItemAttr {

core/codegen/src/derive/uri_display.rs

@@ -1,16 +1,16 @@
 use proc_macro::{Span, TokenStream};
 use devise::*;
 
-use derive::from_form::Form;
-use proc_macro2::TokenStream as TokenStream2;
+use crate::derive::from_form::Form;
+use crate::proc_macro2::TokenStream as TokenStream2;
 
 const NO_EMPTY_FIELDS: &str = "fieldless structs or variants are not supported";
 const NO_NULLARY: &str = "nullary items are not supported";
 const NO_EMPTY_ENUMS: &str = "empty enums are not supported";
 const ONLY_ONE_UNNAMED: &str = "tuple structs or variants must have exactly one field";
 const EXACTLY_ONE_FIELD: &str = "struct must have exactly one field";
 
-fn validate_fields(fields: Fields, parent_span: Span) -> Result<()> {
+fn validate_fields(fields: Fields<'_>, parent_span: Span) -> Result<()> {
     if fields.count() == 0 {
         return Err(parent_span.error(NO_EMPTY_FIELDS))
     } else if fields.are_unnamed() && fields.count() > 1 {
@@ -22,11 +22,11 @@ fn validate_fields(fields: Fields, parent_span: Span) -> Result<()> {
     Ok(())
 }
 
-fn validate_struct(gen: &DeriveGenerator, data: Struct) -> Result<()> {
+fn validate_struct(gen: &DeriveGenerator, data: Struct<'_>) -> Result<()> {
     validate_fields(data.fields(), gen.input.span())
 }
 
-fn validate_enum(gen: &DeriveGenerator, data: Enum) -> Result<()> {
+fn validate_enum(gen: &DeriveGenerator, data: Enum<'_>) -> Result<()> {
     if data.variants().count() == 0 {
         return Err(gen.input.span().error(NO_EMPTY_ENUMS));
     }