diff --git a/diesel_derives/Cargo.toml b/diesel_derives/Cargo.toml
index 9b24e2003d04..4940427cea9e 100644
--- a/diesel_derives/Cargo.toml
+++ b/diesel_derives/Cargo.toml
@@ -9,10 +9,10 @@ homepage = "https://diesel.rs"
 repository = "https://github.com/diesel-rs/diesel/tree/master/diesel_derives"
 
 [dependencies]
-syn = { version = "0.13.0", features = ["full", "fold"] }
-quote = "0.5.0"
+syn = { version = "0.14", features = ["full", "fold"] }
+quote = "0.6"
 clippy = { optional = true, version = "=0.0.195" }
-proc-macro2 = "0.3.0"
+proc-macro2 = "0.4"
 
 [dev-dependencies]
 cfg-if = "0.1.0"
diff --git a/diesel_derives/src/as_changeset.rs b/diesel_derives/src/as_changeset.rs
index 2de39c58869c..b15de24bb05c 100644
--- a/diesel_derives/src/as_changeset.rs
+++ b/diesel_derives/src/as_changeset.rs
@@ -1,6 +1,5 @@
-use quote;
+use proc_macro2::{self, Span};
 use syn;
-use proc_macro2::Span;
 
 use diagnostic_shim::*;
 use field::*;
@@ -8,7 +7,7 @@ use meta::*;
 use model::*;
 use util::*;
 
-pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
+pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
     let treat_none_as_null = MetaItem::with_name(&item.attrs, "changeset_options")
         .map(|meta| {
             meta.warn_if_other_options(&["treat_none_as_null"]);
@@ -18,7 +17,7 @@ pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
         .unwrap_or(Ok(false))?;
     let model = Model::from_item(&item)?;
     let struct_name = &model.name;
-    let table_name = model.table_name();
+    let table_name = &model.table_name();
 
     let (_, ty_generics, where_clause) = item.generics.split_for_impl();
     let mut impl_generics = item.generics.clone();
@@ -91,9 +90,9 @@ pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
 
 fn field_changeset_ty(
     field: &Field,
-    table_name: syn::Ident,
+    table_name: &syn::Ident,
     treat_none_as_null: bool,
-    lifetime: Option<quote::Tokens>,
+    lifetime: Option<proc_macro2::TokenStream>,
 ) -> syn::Type {
     let column_name = field.column_name();
     if !treat_none_as_null && is_option_ty(&field.ty) {
@@ -107,9 +106,9 @@ fn field_changeset_ty(
 
 fn field_changeset_expr(
     field: &Field,
-    table_name: syn::Ident,
+    table_name: &syn::Ident,
     treat_none_as_null: bool,
-    lifetime: Option<quote::Tokens>,
+    lifetime: Option<proc_macro2::TokenStream>,
 ) -> syn::Expr {
     let field_access = field.name.access();
     let column_name = field.column_name();
diff --git a/diesel_derives/src/as_expression.rs b/diesel_derives/src/as_expression.rs
index 98c7a2be8a10..2667d08cce92 100644
--- a/diesel_derives/src/as_expression.rs
+++ b/diesel_derives/src/as_expression.rs
@@ -1,13 +1,12 @@
-use quote;
-use syn;
-
 use meta::*;
+use proc_macro2::{self, Ident, Span};
+use syn;
 use util::*;
 
-pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
+pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
     let dummy_mod = format!(
         "_impl_as_expression_for_{}",
-        item.ident.as_ref().to_lowercase()
+        item.ident.to_string().to_lowercase()
     );
     let flags =
         MetaItem::with_name(&item.attrs, "diesel").unwrap_or_else(|| MetaItem::empty("diesel"));
@@ -106,7 +105,7 @@ pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
 
     if any_sql_types {
         Ok(wrap_in_dummy_mod(
-            dummy_mod.into(),
+            Ident::new(&dummy_mod, Span::call_site()),
             quote! {
                 use self::diesel::expression::AsExpression;
                 use self::diesel::expression::bound::Bound;
diff --git a/diesel_derives/src/associations.rs b/diesel_derives/src/associations.rs
index e2882fc6fbc0..a7aa0993467b 100644
--- a/diesel_derives/src/associations.rs
+++ b/diesel_derives/src/associations.rs
@@ -1,12 +1,11 @@
-use quote;
-use syn;
-
 use diagnostic_shim::*;
 use meta::*;
 use model::*;
+use proc_macro2;
+use syn;
 use util::*;
 
-pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
+pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
     let model = Model::from_item(&item)?;
     let tokens = MetaItem::all_with_name(&item.attrs, "belongs_to")
         .into_iter()
@@ -30,15 +29,15 @@ fn derive_belongs_to(
     model: &Model,
     generics: &syn::Generics,
     meta: MetaItem,
-) -> Result<quote::Tokens, Diagnostic> {
+) -> Result<proc_macro2::TokenStream, Diagnostic> {
     let AssociationOptions {
         parent_struct,
         foreign_key,
     } = AssociationOptions::from_meta(meta)?;
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
-    let foreign_key_field = model.find_column(foreign_key)?;
-    let struct_name = model.name;
+    let foreign_key_field = model.find_column(&foreign_key)?;
+    let struct_name = &model.name;
     let foreign_key_access = foreign_key_field.name.access();
     let foreign_key_ty = inner_of_option_ty(&foreign_key_field.ty);
     let table_name = model.table_name();
@@ -86,7 +85,7 @@ impl AssociationOptions {
         let foreign_key = meta.nested_item("foreign_key")
             .ok()
             .map(|i| i.ident_value())
-            .unwrap_or_else(|| Ok(infer_foreign_key(parent_struct)))?;
+            .unwrap_or_else(|| Ok(infer_foreign_key(&parent_struct)))?;
 
         let unrecognized_options = meta.nested()?.skip(1).filter(|n| n.name() != "foreign_key");
         for ignored in unrecognized_options {
@@ -103,7 +102,7 @@ impl AssociationOptions {
     }
 }
 
-fn infer_foreign_key(name: syn::Ident) -> syn::Ident {
-    let snake_case = camel_to_snake(name.as_ref());
+fn infer_foreign_key(name: &syn::Ident) -> syn::Ident {
+    let snake_case = camel_to_snake(&name.to_string());
     syn::Ident::new(&format!("{}_id", snake_case), name.span())
 }
diff --git a/diesel_derives/src/diesel_numeric_ops.rs b/diesel_derives/src/diesel_numeric_ops.rs
index 155d24594510..4607551cdadb 100644
--- a/diesel_derives/src/diesel_numeric_ops.rs
+++ b/diesel_derives/src/diesel_numeric_ops.rs
@@ -1,10 +1,9 @@
-use quote;
+use proc_macro2::{self, Ident, Span};
 use syn;
-
 use util::*;
 
-pub fn derive(mut item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
-    let struct_name = item.ident;
+pub fn derive(mut item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
+    let struct_name = &item.ident;
 
     {
         let where_clause = item.generics
@@ -21,7 +20,7 @@ pub fn derive(mut item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
     let dummy_name = format!("_impl_diesel_numeric_ops_for_{}", item.ident);
 
     Ok(wrap_in_dummy_mod(
-        dummy_name.to_lowercase().into(),
+        Ident::new(&dummy_name.to_lowercase(), Span::call_site()),
         quote! {
             use self::diesel::expression::{ops, Expression, AsExpression};
             use self::diesel::sql_types::ops::{Add, Sub, Mul, Div};
diff --git a/diesel_derives/src/field.rs b/diesel_derives/src/field.rs
index 05736268a5c2..7edb00aba2ac 100644
--- a/diesel_derives/src/field.rs
+++ b/diesel_derives/src/field.rs
@@ -1,7 +1,7 @@
-use proc_macro2::Span;
+use proc_macro2::{self, Ident, Span};
 use quote;
-use syn::spanned::Spanned;
 use syn;
+use syn::spanned::Spanned;
 
 use meta::*;
 use util::*;
@@ -19,7 +19,7 @@ impl Field {
     pub fn from_struct_field(field: &syn::Field, index: usize) -> Self {
         let column_name_from_attribute =
             MetaItem::with_name(&field.attrs, "column_name").map(|m| m.expect_ident_value());
-        let name = match field.ident {
+        let name = match field.ident.clone() {
             Some(mut x) => {
                 // https://github.com/rust-lang/rust/issues/47983#issuecomment-362817105
                 let span = x.span();
@@ -50,15 +50,16 @@ impl Field {
 
     pub fn column_name(&self) -> syn::Ident {
         self.column_name_from_attribute
+            .clone()
             .unwrap_or_else(|| match self.name {
-                FieldName::Named(x) => x,
+                FieldName::Named(ref x) => x.clone(),
                 _ => {
                     self.span
                         .error(
                             "All fields of tuple structs must be annotated with `#[column_name]`",
                         )
                         .emit();
-                    "unknown_column".into()
+                    Ident::new("unknown_column", Span::call_site())
                 }
             })
     }
@@ -81,7 +82,7 @@ impl FieldName {
         parse_quote!(#tokens)
     }
 
-    pub fn access(&self) -> quote::Tokens {
+    pub fn access(&self) -> proc_macro2::TokenStream {
         let span = self.span();
         // Span of the dot is important due to
         // https://github.com/rust-lang/rust/issues/47312
@@ -90,16 +91,16 @@ impl FieldName {
 
     pub fn span(&self) -> Span {
         match *self {
-            FieldName::Named(x) => x.span(),
+            FieldName::Named(ref x) => x.span(),
             FieldName::Unnamed(ref x) => x.span,
         }
     }
 }
 
 impl quote::ToTokens for FieldName {
-    fn to_tokens(&self, tokens: &mut quote::Tokens) {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
         match *self {
-            FieldName::Named(x) => x.to_tokens(tokens),
+            FieldName::Named(ref x) => x.to_tokens(tokens),
             FieldName::Unnamed(ref x) => x.to_tokens(tokens),
         }
     }
diff --git a/diesel_derives/src/from_sql_row.rs b/diesel_derives/src/from_sql_row.rs
index cfeb1f9ba7db..f1417c837f72 100644
--- a/diesel_derives/src/from_sql_row.rs
+++ b/diesel_derives/src/from_sql_row.rs
@@ -1,10 +1,9 @@
-use quote::Tokens;
-use syn;
-
 use meta::*;
+use proc_macro2::{self, Ident, Span};
+use syn;
 use util::*;
 
-pub fn derive(mut item: syn::DeriveInput) -> Result<Tokens, Diagnostic> {
+pub fn derive(mut item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
     let flags =
         MetaItem::with_name(&item.attrs, "diesel").unwrap_or_else(|| MetaItem::empty("diesel"));
     let struct_ty = ty_for_foreign_derive(&item, &flags)?;
@@ -24,10 +23,13 @@ pub fn derive(mut item: syn::DeriveInput) -> Result<Tokens, Diagnostic> {
     }
     let (impl_generics, _, where_clause) = item.generics.split_for_impl();
 
-    let dummy_mod = format!(
-        "_impl_from_sql_row_for_{}",
-        item.ident.as_ref().to_lowercase()
-    ).into();
+    let dummy_mod = Ident::new(
+        &format!(
+            "_impl_from_sql_row_for_{}",
+            item.ident.to_string().to_lowercase()
+        ),
+        Span::call_site(),
+    );
     Ok(wrap_in_dummy_mod(
         dummy_mod,
         quote! {
diff --git a/diesel_derives/src/identifiable.rs b/diesel_derives/src/identifiable.rs
index 971ce5169d5a..2a97d2a8aeb6 100644
--- a/diesel_derives/src/identifiable.rs
+++ b/diesel_derives/src/identifiable.rs
@@ -1,12 +1,11 @@
-use quote;
-use syn;
-
 use model::*;
+use proc_macro2;
+use syn;
 use util::*;
 
-pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
+pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
     let model = Model::from_item(&item)?;
-    let struct_name = model.name;
+    let struct_name = &model.name;
     let table_name = model.table_name();
 
     let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
@@ -17,7 +16,7 @@ pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
     let (field_ty, field_access): (Vec<_>, Vec<_>) = model
         .primary_key_names
         .iter()
-        .filter_map(|&pk| model.find_column(pk).emit_error())
+        .filter_map(|ref pk| model.find_column(pk).emit_error())
         .map(|f| (&f.ty, f.name.access()))
         .unzip();
 
diff --git a/diesel_derives/src/insertable.rs b/diesel_derives/src/insertable.rs
index 48260dcdcc56..12cd43b1662c 100644
--- a/diesel_derives/src/insertable.rs
+++ b/diesel_derives/src/insertable.rs
@@ -1,12 +1,11 @@
+use proc_macro2::{self, Span};
 use syn;
-use quote;
-use proc_macro2::Span;
 
 use field::*;
 use model::*;
 use util::*;
 
-pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
+pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
     let model = Model::from_item(&item)?;
 
     if model.fields().is_empty() {
@@ -31,8 +30,8 @@ pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
         .iter()
         .map(|f| {
             (
-                (field_ty(f, table_name, None)),
-                (field_expr(f, table_name, None)),
+                (field_ty(f, &table_name, None)),
+                (field_expr(f, &table_name, None)),
             )
         })
         .unzip();
@@ -42,8 +41,8 @@ pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
         .iter()
         .map(|f| {
             (
-                (field_ty(f, table_name, Some(quote!(&'insert)))),
-                (field_expr(f, table_name, Some(quote!(&)))),
+                (field_ty(f, &table_name, Some(quote!(&'insert)))),
+                (field_expr(f, &table_name, Some(quote!(&)))),
             )
         })
         .unzip();
@@ -85,7 +84,11 @@ pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
     ))
 }
 
-fn field_ty(field: &Field, table_name: syn::Ident, lifetime: Option<quote::Tokens>) -> syn::Type {
+fn field_ty(
+    field: &Field,
+    table_name: &syn::Ident,
+    lifetime: Option<proc_macro2::TokenStream>,
+) -> syn::Type {
     if field.has_flag("embed") {
         let field_ty = &field.ty;
         parse_quote!(#lifetime #field_ty)
@@ -101,7 +104,11 @@ fn field_ty(field: &Field, table_name: syn::Ident, lifetime: Option<quote::Token
     }
 }
 
-fn field_expr(field: &Field, table_name: syn::Ident, lifetime: Option<quote::Tokens>) -> syn::Expr {
+fn field_expr(
+    field: &Field,
+    table_name: &syn::Ident,
+    lifetime: Option<proc_macro2::TokenStream>,
+) -> syn::Expr {
     let field_access = field.name.access();
     if field.has_flag("embed") {
         parse_quote!(#lifetime self#field_access)
diff --git a/diesel_derives/src/lib.rs b/diesel_derives/src/lib.rs
index 2fae954e37ab..d3770c60d9f4 100644
--- a/diesel_derives/src/lib.rs
+++ b/diesel_derives/src/lib.rs
@@ -6,9 +6,13 @@
 #![cfg_attr(feature = "clippy", feature(plugin))]
 #![cfg_attr(feature = "clippy", plugin(clippy(conf_file = "../../clippy.toml")))]
 #![cfg_attr(feature = "clippy", allow(option_map_unwrap_or_else, option_map_unwrap_or))]
-#![cfg_attr(feature = "clippy",
-            warn(wrong_pub_self_convention, mut_mut, non_ascii_literal, similar_names,
-                 unicode_not_nfc, if_not_else, items_after_statements, used_underscore_binding))]
+#![cfg_attr(
+    feature = "clippy",
+    warn(
+        wrong_pub_self_convention, mut_mut, non_ascii_literal, similar_names, unicode_not_nfc,
+        if_not_else, items_after_statements, used_underscore_binding
+    )
+)]
 #![cfg_attr(feature = "nightly", feature(proc_macro))]
 
 extern crate proc_macro;
@@ -41,8 +45,9 @@ mod sql_type;
 
 use diagnostic_shim::*;
 
-#[proc_macro_derive(AsChangeset,
-                    attributes(table_name, primary_key, column_name, changeset_options))]
+#[proc_macro_derive(
+    AsChangeset, attributes(table_name, primary_key, column_name, changeset_options)
+)]
 pub fn derive_as_changeset(input: TokenStream) -> TokenStream {
     expand_derive(input, as_changeset::derive)
 }
@@ -98,8 +103,8 @@ pub fn derive_sql_type(input: TokenStream) -> TokenStream {
 }
 
 fn expand_derive(
-    input: TokenStream,
-    f: fn(syn::DeriveInput) -> Result<quote::Tokens, Diagnostic>,
+    input: proc_macro::TokenStream,
+    f: fn(syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic>,
 ) -> TokenStream {
     let item = syn::parse(input).unwrap();
     match f(item) {
diff --git a/diesel_derives/src/meta.rs b/diesel_derives/src/meta.rs
index 23da329db048..9af5f57ae2c9 100644
--- a/diesel_derives/src/meta.rs
+++ b/diesel_derives/src/meta.rs
@@ -1,7 +1,7 @@
-use proc_macro2::Span;
+use proc_macro2::{Ident, Span};
 use syn;
-use syn::spanned::Spanned;
 use syn::fold::Fold;
+use syn::spanned::Spanned;
 
 use resolved_at_shim::*;
 use util::*;
@@ -30,7 +30,7 @@ impl MetaItem {
     pub fn empty(name: &str) -> Self {
         Self {
             meta: syn::Meta::List(syn::MetaList {
-                ident: name.into(),
+                ident: Ident::new(name, Span::call_site()),
                 paren_token: Default::default(),
                 nested: Default::default(),
             }),
@@ -100,7 +100,7 @@ impl MetaItem {
         use syn::Meta::*;
 
         match self.meta {
-            Word(x) => Ok(x),
+            Word(ref x) => Ok(x.clone()),
             _ => {
                 let meta = &self.meta;
                 Err(self.span().error(format!(
@@ -197,7 +197,8 @@ impl MetaItem {
             Ok(x) => x,
             Err(_) => return,
         };
-        let unrecognized_options = nested.filter(|n| !options.contains(&n.name().as_ref()));
+        let unrecognized_options =
+            nested.filter(|n| !options.contains(&n.name().to_string().as_str()));
         for ignored in unrecognized_options {
             ignored
                 .span()
@@ -210,7 +211,7 @@ impl MetaItem {
         use syn::Meta::*;
 
         match self.meta {
-            Word(ident) => ident.span(),
+            Word(ref ident) => ident.span(),
             List(ref meta) => meta.nested.span(),
             NameValue(ref meta) => meta.lit.span(),
         }
diff --git a/diesel_derives/src/model.rs b/diesel_derives/src/model.rs
index ed80ae49baaf..3a6feb755ba4 100644
--- a/diesel_derives/src/model.rs
+++ b/diesel_derives/src/model.rs
@@ -1,5 +1,5 @@
+use proc_macro2::{Ident, Span};
 use syn;
-use proc_macro2::Span;
 
 use diagnostic_shim::*;
 use field::*;
@@ -19,10 +19,10 @@ impl Model {
             MetaItem::with_name(&item.attrs, "table_name").map(|m| m.expect_ident_value());
         let primary_key_names = MetaItem::with_name(&item.attrs, "primary_key")
             .map(|m| Ok(m.nested()?.map(|m| m.expect_word()).collect()))
-            .unwrap_or_else(|| Ok(vec!["id".into()]))?;
+            .unwrap_or_else(|| Ok(vec![Ident::new("id", Span::call_site())]))?;
         let fields = fields_from_item_data(&item.data)?;
         Ok(Self {
-            name: item.ident,
+            name: item.ident.clone(),
             table_name_from_attribute,
             primary_key_names,
             fields,
@@ -30,27 +30,30 @@ impl Model {
     }
 
     pub fn table_name(&self) -> syn::Ident {
-        self.table_name_from_attribute.unwrap_or_else(|| {
+        self.table_name_from_attribute.clone().unwrap_or_else(|| {
             syn::Ident::new(
-                &infer_table_name(self.name.as_ref()),
+                &infer_table_name(&self.name.to_string()),
                 self.name.span().resolved_at(Span::call_site()),
             )
         })
     }
 
     pub fn dummy_mod_name(&self, trait_name: &str) -> syn::Ident {
-        let name = self.name.as_ref().to_lowercase();
-        format!("_impl_{}_for_{}", trait_name, name).into()
+        let name = self.name.to_string().to_lowercase();
+        Ident::new(
+            &format!("_impl_{}_for_{}", trait_name, name),
+            Span::call_site(),
+        )
     }
 
     pub fn fields(&self) -> &[Field] {
         &self.fields
     }
 
-    pub fn find_column(&self, column_name: syn::Ident) -> Result<&Field, Diagnostic> {
+    pub fn find_column(&self, column_name: &syn::Ident) -> Result<&Field, Diagnostic> {
         self.fields()
             .iter()
-            .find(|f| f.column_name() == column_name)
+            .find(|f| f.column_name() == *column_name)
             .ok_or_else(|| {
                 column_name
                     .span()
diff --git a/diesel_derives/src/query_id.rs b/diesel_derives/src/query_id.rs
index b5f99fb9262f..d530062703b6 100644
--- a/diesel_derives/src/query_id.rs
+++ b/diesel_derives/src/query_id.rs
@@ -1,28 +1,29 @@
-use quote;
+use proc_macro2::{self, Ident, Span};
 use syn;
-
 use util::*;
-
-pub fn derive(mut item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
+pub fn derive(mut item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
     for ty_param in item.generics.type_params_mut() {
         ty_param.bounds.push(parse_quote!(QueryId));
     }
     let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
 
-    let struct_name = item.ident;
+    let struct_name = &item.ident;
     let lifetimes = item.generics.lifetimes();
     let query_id_ty_params = item.generics
         .type_params()
-        .map(|ty_param| ty_param.ident)
+        .map(|ty_param| &ty_param.ident)
         .map(|ty_param| quote!(<#ty_param as QueryId>::QueryId));
     let has_static_query_id = item.generics
         .type_params()
-        .map(|ty_param| ty_param.ident)
+        .map(|ty_param| &ty_param.ident)
         .map(|ty_param| quote!(<#ty_param as QueryId>::HAS_STATIC_QUERY_ID));
 
-    let dummy_mod = format!("_impl_query_id_for_{}", item.ident.as_ref().to_lowercase());
+    let dummy_mod = format!(
+        "_impl_query_id_for_{}",
+        item.ident.to_string().to_lowercase()
+    );
     Ok(wrap_in_dummy_mod(
-        dummy_mod.into(),
+        Ident::new(&dummy_mod, Span::call_site()),
         quote! {
             use self::diesel::query_builder::QueryId;
 
diff --git a/diesel_derives/src/queryable.rs b/diesel_derives/src/queryable.rs
index 99ab2a7b3301..7aacc7a37ad3 100644
--- a/diesel_derives/src/queryable.rs
+++ b/diesel_derives/src/queryable.rs
@@ -1,10 +1,9 @@
-use quote;
-use syn;
-
 use model::*;
+use proc_macro2;
+use syn;
 use util::*;
 
-pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
+pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
     let model = Model::from_item(&item)?;
 
     let struct_name = item.ident;
diff --git a/diesel_derives/src/queryable_by_name.rs b/diesel_derives/src/queryable_by_name.rs
index f319368c0b6e..bda26ba12f07 100644
--- a/diesel_derives/src/queryable_by_name.rs
+++ b/diesel_derives/src/queryable_by_name.rs
@@ -1,11 +1,10 @@
-use syn;
-use quote;
-
 use field::*;
 use model::*;
+use proc_macro2;
+use syn;
 use util::*;
 
-pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
+pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
     let model = Model::from_item(&item)?;
 
     let struct_name = item.ident;
@@ -78,8 +77,8 @@ fn sql_type(field: &Field, model: &Model) -> syn::Type {
             parse_quote!(diesel::dsl::SqlTypeOf<#table_name::#column_name>)
         } else {
             let field_name = match field.name {
-                FieldName::Named(ref x) => x.as_ref(),
-                _ => "field",
+                FieldName::Named(ref x) => x.to_string(),
+                _ => "field".into(),
             };
             field
                 .span
diff --git a/diesel_derives/src/sql_type.rs b/diesel_derives/src/sql_type.rs
index f8dee38e154b..c5f1cb71b0ad 100644
--- a/diesel_derives/src/sql_type.rs
+++ b/diesel_derives/src/sql_type.rs
@@ -1,11 +1,10 @@
-use quote;
-use syn;
-
 use meta::*;
+use proc_macro2::{self, Ident, Span};
+use syn;
 use util::*;
 
-pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
-    let struct_name = item.ident;
+pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
+    let struct_name = &item.ident;
     let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
 
     let sqlite_tokens = sqlite_tokens(&item);
@@ -14,7 +13,7 @@ pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
 
     let dummy_name = format!("_impl_sql_type_for_{}", item.ident);
     Ok(wrap_in_dummy_mod(
-        dummy_name.to_lowercase().into(),
+        Ident::new(dummy_name.to_lowercase().as_str(), Span::call_site()),
         quote! {
             impl #impl_generics diesel::sql_types::NotNull
                 for #struct_name #ty_generics
@@ -35,7 +34,7 @@ pub fn derive(item: syn::DeriveInput) -> Result<quote::Tokens, Diagnostic> {
     ))
 }
 
-fn sqlite_tokens(item: &syn::DeriveInput) -> Option<quote::Tokens> {
+fn sqlite_tokens(item: &syn::DeriveInput) -> Option<proc_macro2::TokenStream> {
     MetaItem::with_name(&item.attrs, "sqlite_type")
         .map(|attr| attr.expect_ident_value())
         .and_then(|ty| {
@@ -43,7 +42,7 @@ fn sqlite_tokens(item: &syn::DeriveInput) -> Option<quote::Tokens> {
                 return None;
             }
 
-            let struct_name = item.ident;
+            let struct_name = &item.ident;
             let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
 
             Some(quote! {
@@ -59,7 +58,7 @@ fn sqlite_tokens(item: &syn::DeriveInput) -> Option<quote::Tokens> {
         })
 }
 
-fn mysql_tokens(item: &syn::DeriveInput) -> Option<quote::Tokens> {
+fn mysql_tokens(item: &syn::DeriveInput) -> Option<proc_macro2::TokenStream> {
     MetaItem::with_name(&item.attrs, "mysql_type")
         .map(|attr| attr.expect_ident_value())
         .and_then(|ty| {
@@ -67,7 +66,7 @@ fn mysql_tokens(item: &syn::DeriveInput) -> Option<quote::Tokens> {
                 return None;
             }
 
-            let struct_name = item.ident;
+            let struct_name = &item.ident;
             let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
 
             Some(quote! {
@@ -83,7 +82,7 @@ fn mysql_tokens(item: &syn::DeriveInput) -> Option<quote::Tokens> {
         })
 }
 
-fn pg_tokens(item: &syn::DeriveInput) -> Option<quote::Tokens> {
+fn pg_tokens(item: &syn::DeriveInput) -> Option<proc_macro2::TokenStream> {
     MetaItem::with_name(&item.attrs, "postgres")
         .and_then(|attr| {
             get_type_name(&attr)
@@ -101,7 +100,7 @@ fn pg_tokens(item: &syn::DeriveInput) -> Option<quote::Tokens> {
                 return None;
             }
 
-            let struct_name = item.ident;
+            let struct_name = &item.ident;
             let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
 
             let metadata_fn = match ty {
diff --git a/diesel_derives/src/util.rs b/diesel_derives/src/util.rs
index 103022b575bc..3448ffaf5a5d 100644
--- a/diesel_derives/src/util.rs
+++ b/diesel_derives/src/util.rs
@@ -1,11 +1,10 @@
-use proc_macro2::Span;
-use quote::Tokens;
+use proc_macro2::{Span, TokenStream};
 use syn::*;
 
 pub use diagnostic_shim::*;
 use meta::*;
 
-pub fn wrap_in_dummy_mod(const_name: Ident, item: Tokens) -> Tokens {
+pub fn wrap_in_dummy_mod(const_name: Ident, item: TokenStream) -> TokenStream {
     let call_site = root_span(Span::call_site());
     let use_everything = quote_spanned!(call_site=> __diesel_use_everything!());
     quote! {
@@ -64,7 +63,7 @@ pub fn ty_for_foreign_derive(item: &DeriveInput, flags: &MetaItem) -> Result<Typ
                 .error("foreign_derive can only be used with structs")),
         }
     } else {
-        let ident = item.ident;
+        let ident = &item.ident;
         let (_, ty_generics, ..) = item.generics.split_for_impl();
         Ok(parse_quote!(#ident #ty_generics))
     }
diff --git a/diesel_derives/tests/queryable.rs b/diesel_derives/tests/queryable.rs
index e6cafdbb830e..d30114bb4ab4 100644
--- a/diesel_derives/tests/queryable.rs
+++ b/diesel_derives/tests/queryable.rs
@@ -1,6 +1,6 @@
 use diesel::dsl::sql;
-use diesel::*;
 use diesel::sql_types::Integer;
+use diesel::*;
 
 use helpers::connection;