Update to 2018

* Fix relative visibility in darling_core
* Fix imports to use crate::
* Remove most unnecessary `#[macro_use]` and `extern crate` lines
* Fix all warnings in tests and examples
* Add self:: to core/lib.rs to compile on 1.31.0

First step of #127

Cargo.toml

@@ -10,6 +10,7 @@ implementing custom derives.
 """
 license = "MIT"
 readme = "README.md"
+edition = "2018"
 exclude = ["/.travis.yml", "/publish.sh", "/.github/**"]
 
 [badges]

core/Cargo.toml

@@ -8,6 +8,7 @@ Helper crate for proc-macro library for reading attributes into structs when
 implementing custom derives. Use https://crates.io/crates/darling in your code.
 """
 license = "MIT"
+edition = "2018"
 
 [features]
 diagnostics = []

core/src/ast/data.rs

@@ -4,10 +4,10 @@ use proc_macro2::{Span, TokenStream};
 use quote::ToTokens;
 use syn::spanned::Spanned;
 
-use usage::{
+use crate::usage::{
     self, IdentRefSet, IdentSet, LifetimeRefSet, LifetimeSet, UsesLifetimes, UsesTypeParams,
 };
-use {Error, FromField, FromVariant, Result};
+use crate::{Error, FromField, FromVariant, Result};
 
 /// A struct or enum body.
 ///

core/src/ast/generics.rs

@@ -3,9 +3,7 @@
 use std::iter::Iterator;
 use std::slice::Iter;
 
-use syn;
-
-use {FromGenericParam, FromGenerics, FromTypeParam, Result};
+use crate::{FromGenericParam, FromGenerics, FromTypeParam, Result};
 
 /// Extension trait for `GenericParam` to support getting values by variant.
 ///
@@ -179,10 +177,8 @@ impl<'a, P: GenericParamExt> Iterator for TypeParams<'a, P> {
 
 #[cfg(test)]
 mod tests {
-    use syn;
-
     use super::{GenericParam, Generics};
-    use FromGenerics;
+    use crate::FromGenerics;
 
     #[test]
     fn generics() {

core/src/codegen/attr_extractor.rs

@@ -1,7 +1,7 @@
 use proc_macro2::TokenStream;
 
-use options::ForwardAttrs;
-use util::PathList;
+use crate::options::ForwardAttrs;
+use crate::util::PathList;
 
 /// Infrastructure for generating an attribute extractor.
 pub trait ExtractAttribute {

core/src/codegen/field.rs

@@ -4,8 +4,8 @@ use proc_macro2::TokenStream;
 use quote::{ToTokens, TokenStreamExt};
 use syn::{Ident, Path, Type};
 
-use codegen::{DefaultExpression, PostfixTransform};
-use usage::{self, IdentRefSet, IdentSet, UsesTypeParams};
+use crate::codegen::{DefaultExpression, PostfixTransform};
+use crate::usage::{self, IdentRefSet, IdentSet, UsesTypeParams};
 
 /// Properties needed to generate code for a field in all the contexts
 /// where one may appear.

core/src/codegen/from_derive_impl.rs

@@ -1,11 +1,13 @@
 use proc_macro2::TokenStream;
 use quote::ToTokens;
-use syn::{self, Ident};
-
-use ast::Data;
-use codegen::{ExtractAttribute, OuterFromImpl, TraitImpl};
-use options::{ForwardAttrs, Shape};
-use util::PathList;
+use syn::Ident;
+
+use crate::{
+    ast::Data,
+    codegen::{ExtractAttribute, OuterFromImpl, TraitImpl},
+    options::{ForwardAttrs, Shape},
+    util::PathList,
+};
 
 pub struct FromDeriveInputImpl<'a> {
     pub ident: Option<&'a Ident>,

core/src/codegen/from_field.rs

@@ -1,10 +1,12 @@
 use proc_macro2::TokenStream;
 use quote::ToTokens;
-use syn::{self, Ident};
+use syn::Ident;
 
-use codegen::{ExtractAttribute, OuterFromImpl, TraitImpl};
-use options::ForwardAttrs;
-use util::PathList;
+use crate::{
+    codegen::{ExtractAttribute, OuterFromImpl, TraitImpl},
+    options::ForwardAttrs,
+    util::PathList,
+};
 
 /// `impl FromField` generator. This is used for parsing an individual
 /// field and its attributes.

core/src/codegen/from_meta_impl.rs

@@ -1,9 +1,8 @@
 use proc_macro2::TokenStream;
 use quote::ToTokens;
-use syn;
 
-use ast::{Data, Fields, Style};
-use codegen::{Field, OuterFromImpl, TraitImpl, Variant};
+use crate::ast::{Data, Fields, Style};
+use crate::codegen::{Field, OuterFromImpl, TraitImpl, Variant};
 
 pub struct FromMetaImpl<'a> {
     pub base: TraitImpl<'a>,

core/src/codegen/from_type_param.rs

@@ -1,10 +1,10 @@
 use proc_macro2::TokenStream;
 use quote::ToTokens;
-use syn::{self, Ident};
+use syn::Ident;
 
-use codegen::{ExtractAttribute, OuterFromImpl, TraitImpl};
-use options::ForwardAttrs;
-use util::PathList;
+use crate::codegen::{ExtractAttribute, OuterFromImpl, TraitImpl};
+use crate::options::ForwardAttrs;
+use crate::util::PathList;
 
 pub struct FromTypeParamImpl<'a> {
     pub base: TraitImpl<'a>,

core/src/codegen/from_variant_impl.rs

@@ -1,10 +1,10 @@
 use proc_macro2::TokenStream;
 use quote::ToTokens;
-use syn::{self, Ident};
+use syn::Ident;
 
-use codegen::{ExtractAttribute, OuterFromImpl, TraitImpl};
-use options::{DataShape, ForwardAttrs};
-use util::PathList;
+use crate::codegen::{ExtractAttribute, OuterFromImpl, TraitImpl};
+use crate::options::{DataShape, ForwardAttrs};
+use crate::util::PathList;
 
 pub struct FromVariantImpl<'a> {
     pub base: TraitImpl<'a>,

core/src/codegen/mod.rs

@@ -13,7 +13,7 @@ mod trait_impl;
 mod variant;
 mod variant_data;
 
-pub(in codegen) use self::attr_extractor::ExtractAttribute;
+pub(in crate::codegen) use self::attr_extractor::ExtractAttribute;
 pub use self::default_expr::DefaultExpression;
 pub use self::field::Field;
 pub use self::from_derive_impl::FromDeriveInputImpl;

core/src/codegen/outer_from_impl.rs

@@ -2,8 +2,8 @@ use proc_macro2::TokenStream;
 use quote::{ToTokens, TokenStreamExt};
 use syn::{GenericParam, Generics, Path, TraitBound, TraitBoundModifier, TypeParamBound};
 
-use codegen::TraitImpl;
-use usage::IdentSet;
+use crate::codegen::TraitImpl;
+use crate::usage::IdentSet;
 
 /// Wrapper for "outer From" traits, such as `FromDeriveInput`, `FromVariant`, and `FromField`.
 pub trait OuterFromImpl<'a> {

core/src/codegen/trait_impl.rs

@@ -1,11 +1,12 @@
 use proc_macro2::TokenStream;
 use syn::{Generics, Ident, WherePredicate};
 
-use ast::{Data, Fields};
-use codegen::error::{ErrorCheck, ErrorDeclaration};
-use codegen::field;
-use codegen::{DefaultExpression, Field, FieldsGen, PostfixTransform, Variant};
-use usage::{CollectTypeParams, IdentSet, Purpose};
+use crate::ast::{Data, Fields};
+use crate::codegen::{
+    error::{ErrorCheck, ErrorDeclaration},
+    field, DefaultExpression, Field, FieldsGen, PostfixTransform, Variant,
+};
+use crate::usage::{CollectTypeParams, IdentSet, Purpose};
 
 #[derive(Debug)]
 pub struct TraitImpl<'a> {
@@ -86,7 +87,7 @@ impl<'a> TraitImpl<'a> {
     }
 
     /// Generate local variable declarations for all fields.
-    pub(in codegen) fn local_declarations(&self) -> TokenStream {
+    pub(in crate::codegen) fn local_declarations(&self) -> TokenStream {
         if let Data::Struct(ref vd) = self.data {
             let vdr = vd.as_ref().map(Field::as_declaration);
             let decls = vdr.fields.as_slice();
@@ -97,7 +98,7 @@ impl<'a> TraitImpl<'a> {
     }
 
     /// Generate immutable variable declarations for all fields.
-    pub(in codegen) fn immutable_declarations(&self) -> TokenStream {
+    pub(in crate::codegen) fn immutable_declarations(&self) -> TokenStream {
         if let Data::Struct(ref vd) = self.data {
             let vdr = vd.as_ref().map(|f| field::Declaration::new(f, false));
             let decls = vdr.fields.as_slice();
@@ -107,12 +108,12 @@ impl<'a> TraitImpl<'a> {
         }
     }
 
-    pub(in codegen) fn post_transform_call(&self) -> Option<TokenStream> {
+    pub(in crate::codegen) fn post_transform_call(&self) -> Option<TokenStream> {
         self.post_transform.map(|pt| quote!(#pt))
     }
 
     /// Generate local variable declaration and initialization for instance from which missing fields will be taken.
-    pub(in codegen) fn fallback_decl(&self) -> TokenStream {
+    pub(in crate::codegen) fn fallback_decl(&self) -> TokenStream {
         let default = self.default.as_ref().map(DefaultExpression::as_declaration);
         quote!(#default)
     }
@@ -127,12 +128,12 @@ impl<'a> TraitImpl<'a> {
         }
     }
 
-    pub(in codegen) fn initializers(&self) -> TokenStream {
+    pub(in crate::codegen) fn initializers(&self) -> TokenStream {
         self.make_field_ctx().initializers()
     }
 
     /// Generate the loop which walks meta items looking for property matches.
-    pub(in codegen) fn core_loop(&self) -> TokenStream {
+    pub(in crate::codegen) fn core_loop(&self) -> TokenStream {
         self.make_field_ctx().core_loop()
     }
 

core/src/codegen/variant.rs

@@ -4,10 +4,10 @@ use proc_macro2::TokenStream;
 use quote::{ToTokens, TokenStreamExt};
 use syn::Ident;
 
-use ast::Fields;
-use codegen::error::{ErrorCheck, ErrorDeclaration};
-use codegen::{Field, FieldsGen};
-use usage::{self, IdentRefSet, IdentSet, UsesTypeParams};
+use crate::ast::Fields;
+use crate::codegen::error::{ErrorCheck, ErrorDeclaration};
+use crate::codegen::{Field, FieldsGen};
+use crate::usage::{self, IdentRefSet, IdentSet, UsesTypeParams};
 
 /// A variant of the enum which is deriving `FromMeta`.
 #[derive(Debug, Clone, PartialEq, Eq)]

core/src/codegen/variant_data.rs

@@ -1,8 +1,7 @@
 use proc_macro2::TokenStream;
 
-use ast::Fields;
-use ast::Style;
-use codegen::Field;
+use crate::ast::{Fields, Style};
+use crate::codegen::Field;
 
 pub struct FieldsGen<'a> {
     fields: &'a Fields<Field<'a>>,
@@ -18,7 +17,7 @@ impl<'a> FieldsGen<'a> {
     }
 
     /// Create declarations for all the fields in the struct.
-    pub(in codegen) fn declarations(&self) -> TokenStream {
+    pub(in crate::codegen) fn declarations(&self) -> TokenStream {
         match *self.fields {
             Fields {
                 style: Style::Struct,
@@ -33,7 +32,7 @@ impl<'a> FieldsGen<'a> {
     }
 
     /// Generate the loop which walks meta items looking for property matches.
-    pub(in codegen) fn core_loop(&self) -> TokenStream {
+    pub(in crate::codegen) fn core_loop(&self) -> TokenStream {
         let arms = self.fields.as_ref().map(Field::as_match);
 
         // If we're allowing unknown fields, then handling one is a no-op.
@@ -84,7 +83,7 @@ impl<'a> FieldsGen<'a> {
         }
     }
 
-    pub(in codegen) fn initializers(&self) -> TokenStream {
+    pub(in crate::codegen) fn initializers(&self) -> TokenStream {
         let inits = self.fields.as_ref().map(Field::as_initializer);
         let inits = inits.iter();
 

core/src/derive.rs

@@ -5,7 +5,7 @@ use proc_macro2::TokenStream;
 use quote::ToTokens;
 use syn::DeriveInput;
 
-use options;
+use crate::options;
 
 /// Run an expression which returns a `darling::Result`, then either return the tokenized
 /// representation of the `Ok` value, or the tokens of the compiler errors in the `Err` case.

core/src/error/kind.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use error::Error;
+use crate::error::Error;
 
 type DeriveInputShape = String;
 type FieldName = String;
@@ -10,7 +10,7 @@ type MetaFormat = String;
 // Don't want to publicly commit to ErrorKind supporting equality yet, but
 // not having it makes testing very difficult.
 #[cfg_attr(test, derive(Clone, PartialEq, Eq))]
-pub(in error) enum ErrorKind {
+pub(in crate::error) enum ErrorKind {
     /// An arbitrary error message.
     Custom(String),
     DuplicateField(FieldName),
@@ -108,7 +108,7 @@ impl From<ErrorUnknownField> for ErrorKind {
 // Don't want to publicly commit to ErrorKind supporting equality yet, but
 // not having it makes testing very difficult.
 #[cfg_attr(test, derive(Clone, PartialEq, Eq))]
-pub(in error) struct ErrorUnknownField {
+pub(in crate::error) struct ErrorUnknownField {
     name: String,
     did_you_mean: Option<String>,
 }

core/src/error/mod.rs

@@ -74,7 +74,7 @@ fn path_to_string(path: &syn::Path) -> String {
 
 /// Error creation functions
 impl Error {
-    pub(in error) fn new(kind: ErrorKind) -> Self {
+    pub(in crate::error) fn new(kind: ErrorKind) -> Self {
         Error {
             kind,
             locations: Vec::new(),

core/src/from_derive_input.rs

@@ -1,6 +1,6 @@
 use syn::DeriveInput;
 
-use Result;
+use crate::Result;
 
 /// Creates an instance by parsing an entire proc-macro `derive` input,
 /// including the, identity, generics, and visibility of the type.

core/src/from_field.rs

@@ -1,6 +1,6 @@
-use syn::{self, Field};
+use syn::Field;
 
-use Result;
+use crate::Result;
 
 /// Creates an instance by parsing an individual field and its attributes.
 pub trait FromField: Sized {

core/src/from_generic_param.rs

@@ -1,6 +1,4 @@
-use syn;
-
-use Result;
+use crate::Result;
 
 /// Creates an instance by parsing a specific `syn::GenericParam`.
 /// This can be a type param, a lifetime, or a const param.

core/src/from_generics.rs

@@ -1,6 +1,6 @@
 use syn::Generics;
 
-use Result;
+use crate::Result;
 
 /// Creates an instance by parsing an entire generics declaration, including the
 /// `where` clause.

core/src/from_meta.rs

@@ -7,10 +7,9 @@ use std::rc::Rc;
 use std::sync::atomic::AtomicBool;
 use std::sync::Arc;
 
-use ident_case;
-use syn::{self, Expr, Lit, Meta, NestedMeta};
+use syn::{Expr, Lit, Meta, NestedMeta};
 
-use {Error, Result};
+use crate::{Error, Result};
 
 /// Create an instance from an item in an attribute declaration.
 ///
@@ -584,9 +583,8 @@ hash_map!(syn::Path);
 #[cfg(test)]
 mod tests {
     use proc_macro2::TokenStream;
-    use syn;
 
-    use {Error, FromMeta, Result};
+    use crate::{Error, FromMeta, Result};
 
     /// parse a string as a syn::Meta instance.
     fn pm(tokens: TokenStream) -> ::std::result::Result<syn::Meta, String> {