Merge pull request diesel-rs#2246 from diesel-rs/sg-use-free-constant

Use unnamed free constants to wrap derive impls

Author: weiznich

.travis.yml

@@ -54,7 +54,7 @@ matrix:
     env: RUSTFLAGS="--cap-lints=warn"
     script:
     - (cd diesel_compile_tests && cargo test)
-  - rust: 1.36.0
+  - rust: 1.37.0
     name: "Rustfmt && Clippy"
     script:
     - rustup component add rustfmt clippy
@@ -66,8 +66,8 @@ matrix:
     - SQLITE_DATABASE_URL=/tmp/test.db
     script:
     - (cd diesel_cli && cargo test --no-default-features --features "sqlite-bundled")
-  - rust: 1.36.0
-    name: "Minimal supported rust version == 1.36.0"
+  - rust: 1.37.0
+     name: "Minimal supported rust version == 1.37.0"
     script:
     - cargo check --all
 

diesel_derives/src/as_changeset.rs

@@ -58,35 +58,32 @@ pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagno
             .emit();
     }
 
-    Ok(wrap_in_dummy_mod(
-        model.dummy_mod_name("as_changeset"),
-        quote!(
-            use diesel::query_builder::AsChangeset;
-            use diesel::prelude::*;
+    Ok(wrap_in_dummy_mod(quote!(
+        use diesel::query_builder::AsChangeset;
+        use diesel::prelude::*;
 
-            impl #impl_generics AsChangeset for &'update #struct_name #ty_generics
-            #where_clause
-            {
-                type Target = #table_name::table;
-                type Changeset = <(#(#ref_changeset_ty,)*) as AsChangeset>::Changeset;
+        impl #impl_generics AsChangeset for &'update #struct_name #ty_generics
+        #where_clause
+        {
+            type Target = #table_name::table;
+            type Changeset = <(#(#ref_changeset_ty,)*) as AsChangeset>::Changeset;
 
-                fn as_changeset(self) -> Self::Changeset {
-                    (#(#ref_changeset_expr,)*).as_changeset()
-                }
+            fn as_changeset(self) -> Self::Changeset {
+                (#(#ref_changeset_expr,)*).as_changeset()
             }
+        }
 
-            impl #impl_generics AsChangeset for #struct_name #ty_generics
-            #where_clause
-            {
-                type Target = #table_name::table;
-                type Changeset = <(#(#direct_changeset_ty,)*) as AsChangeset>::Changeset;
+        impl #impl_generics AsChangeset for #struct_name #ty_generics
+        #where_clause
+        {
+            type Target = #table_name::table;
+            type Changeset = <(#(#direct_changeset_ty,)*) as AsChangeset>::Changeset;
 
-                fn as_changeset(self) -> Self::Changeset {
-                    (#(#direct_changeset_expr,)*).as_changeset()
-                }
+            fn as_changeset(self) -> Self::Changeset {
+                (#(#direct_changeset_expr,)*).as_changeset()
             }
-        ),
-    ))
+        }
+    )))
 }
 
 fn field_changeset_ty(

diesel_derives/src/as_expression.rs

@@ -1,11 +1,10 @@
-use proc_macro2::{self, Ident, Span};
+use proc_macro2;
 use syn;
 
 use meta::*;
 use util::*;
 
 pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagnostic> {
-    let dummy_mod = format!("_impl_as_expression_for_{}", item.ident,).to_lowercase();
     let flags =
         MetaItem::with_name(&item.attrs, "diesel").unwrap_or_else(|| MetaItem::empty("diesel"));
     let is_sized = !flags.has_flag("not_sized");
@@ -102,17 +101,14 @@ pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagno
     });
 
     if any_sql_types {
-        Ok(wrap_in_dummy_mod(
-            Ident::new(&dummy_mod, Span::call_site()),
-            quote! {
-                use diesel::expression::AsExpression;
-                use diesel::expression::bound::Bound;
-                use diesel::sql_types::Nullable;
-                use diesel::serialize::{self, ToSql, Output};
-
-                #(#tokens)*
-            },
-        ))
+        Ok(wrap_in_dummy_mod(quote! {
+            use diesel::expression::AsExpression;
+            use diesel::expression::bound::Bound;
+            use diesel::sql_types::Nullable;
+            use diesel::serialize::{self, ToSql, Output};
+
+            #(#tokens)*
+        }))
     } else {
         Ok(quote!())
     }

diesel_derives/src/associations.rs

@@ -23,10 +23,7 @@ pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagno
             },
         );
 
-    Ok(wrap_in_dummy_mod(
-        model.dummy_mod_name("associations"),
-        quote!(#(#tokens)*),
-    ))
+    Ok(wrap_in_dummy_mod(quote!(#(#tokens)*)))
 }
 
 fn derive_belongs_to(

diesel_derives/src/diesel_numeric_ops.rs

@@ -1,4 +1,4 @@
-use proc_macro2::{self, Ident, Span};
+use proc_macro2;
 use syn;
 
 use util::*;
@@ -19,61 +19,56 @@ pub fn derive(mut item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Di
     impl_generics.params.push(parse_quote!(__Rhs));
     let (impl_generics, _, _) = impl_generics.split_for_impl();
 
-    let dummy_name = format!("_impl_diesel_numeric_ops_for_{}", item.ident);
+    Ok(wrap_in_dummy_mod(quote! {
+        use diesel::expression::{ops, Expression, AsExpression};
+        use diesel::sql_types::ops::{Add, Sub, Mul, Div};
 
-    Ok(wrap_in_dummy_mod(
-        Ident::new(&dummy_name.to_lowercase(), Span::call_site()),
-        quote! {
-            use diesel::expression::{ops, Expression, AsExpression};
-            use diesel::sql_types::ops::{Add, Sub, Mul, Div};
+        impl #impl_generics ::std::ops::Add<__Rhs> for #struct_name #ty_generics
+        #where_clause
+            <Self as Expression>::SqlType: Add,
+            __Rhs: AsExpression<<<Self as Expression>::SqlType as Add>::Rhs>,
+        {
+            type Output = ops::Add<Self, __Rhs::Expression>;
 
-            impl #impl_generics ::std::ops::Add<__Rhs> for #struct_name #ty_generics
-            #where_clause
-                <Self as Expression>::SqlType: Add,
-                __Rhs: AsExpression<<<Self as Expression>::SqlType as Add>::Rhs>,
-            {
-                type Output = ops::Add<Self, __Rhs::Expression>;
-
-                fn add(self, rhs: __Rhs) -> Self::Output {
-                    ops::Add::new(self, rhs.as_expression())
-                }
+            fn add(self, rhs: __Rhs) -> Self::Output {
+                ops::Add::new(self, rhs.as_expression())
             }
+        }
 
-            impl #impl_generics ::std::ops::Sub<__Rhs> for #struct_name #ty_generics
-            #where_clause
-                <Self as Expression>::SqlType: Sub,
-                __Rhs: AsExpression<<<Self as Expression>::SqlType as Sub>::Rhs>,
-            {
-                type Output = ops::Sub<Self, __Rhs::Expression>;
+        impl #impl_generics ::std::ops::Sub<__Rhs> for #struct_name #ty_generics
+        #where_clause
+            <Self as Expression>::SqlType: Sub,
+            __Rhs: AsExpression<<<Self as Expression>::SqlType as Sub>::Rhs>,
+        {
+            type Output = ops::Sub<Self, __Rhs::Expression>;
 
-                fn sub(self, rhs: __Rhs) -> Self::Output {
-                    ops::Sub::new(self, rhs.as_expression())
-                }
+            fn sub(self, rhs: __Rhs) -> Self::Output {
+                ops::Sub::new(self, rhs.as_expression())
             }
+        }
 
-            impl #impl_generics ::std::ops::Mul<__Rhs> for #struct_name #ty_generics
-            #where_clause
-                <Self as Expression>::SqlType: Mul,
-                __Rhs: AsExpression<<<Self as Expression>::SqlType as Mul>::Rhs>,
-            {
-                type Output = ops::Mul<Self, __Rhs::Expression>;
+        impl #impl_generics ::std::ops::Mul<__Rhs> for #struct_name #ty_generics
+        #where_clause
+            <Self as Expression>::SqlType: Mul,
+            __Rhs: AsExpression<<<Self as Expression>::SqlType as Mul>::Rhs>,
+        {
+            type Output = ops::Mul<Self, __Rhs::Expression>;
 
-                fn mul(self, rhs: __Rhs) -> Self::Output {
-                    ops::Mul::new(self, rhs.as_expression())
-                }
+            fn mul(self, rhs: __Rhs) -> Self::Output {
+                ops::Mul::new(self, rhs.as_expression())
             }
+        }
 
-            impl #impl_generics ::std::ops::Div<__Rhs> for #struct_name #ty_generics
-            #where_clause
-                <Self as Expression>::SqlType: Div,
-                __Rhs: AsExpression<<<Self as Expression>::SqlType as Div>::Rhs>,
-            {
-                type Output = ops::Div<Self, __Rhs::Expression>;
+        impl #impl_generics ::std::ops::Div<__Rhs> for #struct_name #ty_generics
+        #where_clause
+            <Self as Expression>::SqlType: Div,
+            __Rhs: AsExpression<<<Self as Expression>::SqlType as Div>::Rhs>,
+        {
+            type Output = ops::Div<Self, __Rhs::Expression>;
 
-                fn div(self, rhs: __Rhs) -> Self::Output {
-                    ops::Div::new(self, rhs.as_expression())
-                }
+            fn div(self, rhs: __Rhs) -> Self::Output {
+                ops::Div::new(self, rhs.as_expression())
             }
-        },
-    ))
+        }
+    }))
 }

diesel_derives/src/from_sql_row.rs

@@ -25,31 +25,27 @@ pub fn derive(mut item: syn::DeriveInput) -> Result<TokenStream, Diagnostic> {
     }
     let (impl_generics, _, where_clause) = item.generics.split_for_impl();
 
-    let dummy_mod = format!("_impl_from_sql_row_for_{}", item.ident,).to_lowercase();
-    Ok(wrap_in_dummy_mod(
-        Ident::new(&dummy_mod, Span::call_site()),
-        quote! {
-            use diesel::deserialize::{self, FromSql, FromSqlRow, Queryable};
+    Ok(wrap_in_dummy_mod(quote! {
+        use diesel::deserialize::{self, FromSql, FromSqlRow, Queryable};
 
-            impl #impl_generics FromSqlRow<__ST, __DB> for #struct_ty
-            #where_clause
+        impl #impl_generics FromSqlRow<__ST, __DB> for #struct_ty
+        #where_clause
+        {
+            fn build_from_row<R: diesel::row::Row<__DB>>(row: &mut R)
+                -> deserialize::Result<Self>
             {
-                fn build_from_row<R: diesel::row::Row<__DB>>(row: &mut R)
-                    -> deserialize::Result<Self>
-                {
-                    FromSql::<__ST, __DB>::from_sql(row.take())
-                }
+                FromSql::<__ST, __DB>::from_sql(row.take())
             }
+        }
 
-            impl #impl_generics Queryable<__ST, __DB> for #struct_ty
-            #where_clause
-            {
-                type Row = Self;
+        impl #impl_generics Queryable<__ST, __DB> for #struct_ty
+        #where_clause
+        {
+            type Row = Self;
 
-                fn build(row: Self::Row) -> Self {
-                    row
-                }
+            fn build(row: Self::Row) -> Self {
+                row
             }
-        },
-    ))
+        }
+    }))
 }

diesel_derives/src/identifiable.rs

@@ -21,30 +21,27 @@ pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagno
         .map(|f| (&f.ty, f.name.access()))
         .unzip();
 
-    Ok(wrap_in_dummy_mod(
-        model.dummy_mod_name("identifiable"),
-        quote! {
-            use diesel::associations::{HasTable, Identifiable};
-
-            impl #impl_generics HasTable for #struct_name #ty_generics
-            #where_clause
-            {
-                type Table = #table_name::table;
-
-                fn table() -> Self::Table {
-                    #table_name::table
-                }
+    Ok(wrap_in_dummy_mod(quote! {
+        use diesel::associations::{HasTable, Identifiable};
+
+        impl #impl_generics HasTable for #struct_name #ty_generics
+        #where_clause
+        {
+            type Table = #table_name::table;
+
+            fn table() -> Self::Table {
+                #table_name::table
             }
+        }
 
-            impl #ref_generics Identifiable for &'ident #struct_name #ty_generics
-            #where_clause
-            {
-                type Id = (#(&'ident #field_ty),*);
+        impl #ref_generics Identifiable for &'ident #struct_name #ty_generics
+        #where_clause
+        {
+            type Id = (#(&'ident #field_ty),*);
 
-                fn id(self) -> Self::Id {
-                    (#(&self#field_access),*)
-                }
+            fn id(self) -> Self::Id {
+                (#(&self#field_access),*)
             }
-        },
-    ))
+        }
+    }))
 }