Skip to content

Commit 90a2a1a

Browse files
weiznichweiznich
committedApr 11, 2025·
Rework more derives to avoid similar problems in the future
* Always use fully qualified paths instead of imports * Always specify traits instead of relaying of resolution of associated types
1 parent 17c09d3 commit 90a2a1a

File tree

10 files changed

+111
-114
lines changed

10 files changed

+111
-114
lines changed
 

‎diesel_derives/src/as_changeset.rs

Lines changed: 20 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -131,14 +131,14 @@ pub fn derive(item: DeriveInput) -> Result<TokenStream> {
131131
}
132132

133133
let changeset_owned = quote! {
134-
impl #impl_generics AsChangeset for #struct_name #ty_generics
134+
impl #impl_generics diesel::query_builder::AsChangeset for #struct_name #ty_generics
135135
#where_clause
136136
{
137137
type Target = #table_name::table;
138-
type Changeset = <(#(#direct_field_ty,)*) as AsChangeset>::Changeset;
138+
type Changeset = <(#(#direct_field_ty,)*) as diesel::query_builder::AsChangeset>::Changeset;
139139

140-
fn as_changeset(self) -> Self::Changeset {
141-
(#(#direct_field_assign,)*).as_changeset()
140+
fn as_changeset(self) -> <Self as diesel::query_builder::AsChangeset>::Changeset {
141+
diesel::query_builder::AsChangeset::as_changeset((#(#direct_field_assign,)*))
142142
}
143143
}
144144
};
@@ -149,14 +149,14 @@ pub fn derive(item: DeriveInput) -> Result<TokenStream> {
149149
let (impl_generics, _, _) = impl_generics.split_for_impl();
150150

151151
quote! {
152-
impl #impl_generics AsChangeset for &'update #struct_name #ty_generics
152+
impl #impl_generics diesel::query_builder::AsChangeset for &'update #struct_name #ty_generics
153153
#where_clause
154154
{
155155
type Target = #table_name::table;
156-
type Changeset = <(#(#ref_field_ty,)*) as AsChangeset>::Changeset;
156+
type Changeset = <(#(#ref_field_ty,)*) as diesel::query_builder::AsChangeset>::Changeset;
157157

158-
fn as_changeset(self) -> Self::Changeset {
159-
(#(#ref_field_assign,)*).as_changeset()
158+
fn as_changeset(self) -> <Self as diesel::query_builder::AsChangeset>::Changeset {
159+
diesel::query_builder::AsChangeset::as_changeset((#(#ref_field_assign,)*))
160160
}
161161
}
162162
}
@@ -165,9 +165,6 @@ pub fn derive(item: DeriveInput) -> Result<TokenStream> {
165165
};
166166

167167
Ok(wrap_in_dummy_mod(quote!(
168-
use diesel::query_builder::AsChangeset;
169-
use diesel::prelude::*;
170-
171168
#changeset_owned
172169

173170
#changeset_borrowed
@@ -213,12 +210,18 @@ fn field_changeset_expr(
213210
let column_name = field.column_name()?.to_ident()?;
214211
if !treat_none_as_null && is_option_ty(&field.ty) {
215212
if lifetime.is_some() {
216-
Ok(quote!(self.#field_name.as_ref().map(|x| #table_name::#column_name.eq(x))))
213+
Ok(
214+
quote!(self.#field_name.as_ref().map(|x| diesel::ExpressionMethods::eq(#table_name::#column_name, x))),
215+
)
217216
} else {
218-
Ok(quote!(self.#field_name.map(|x| #table_name::#column_name.eq(x))))
217+
Ok(
218+
quote!(self.#field_name.map(|x| diesel::ExpressionMethods::eq(#table_name::#column_name, x))),
219+
)
219220
}
220221
} else {
221-
Ok(quote!(#table_name::#column_name.eq(#lifetime self.#field_name)))
222+
Ok(
223+
quote!(diesel::ExpressionMethods::eq(#table_name::#column_name, #lifetime self.#field_name)),
224+
)
222225
}
223226
}
224227

@@ -247,7 +250,9 @@ fn field_changeset_expr_serialize_as(
247250
let column_name = field.column_name()?.to_ident()?;
248251
let column: Expr = parse_quote!(#table_name::#column_name);
249252
if !treat_none_as_null && is_option_ty(&field.ty) {
250-
Ok(quote!(self.#field_name.map(|x| #column.eq(::std::convert::Into::<#ty>::into(x)))))
253+
Ok(
254+
quote!(self.#field_name.map(|x| diesel::ExpressionMethods::eq(#column, ::std::convert::Into::<#ty>::into(x)))),
255+
)
251256
} else {
252257
Ok(quote!(#column.eq(::std::convert::Into::<#ty>::into(self.#field_name))))
253258
}

‎diesel_derives/src/as_expression.rs

Lines changed: 30 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -36,56 +36,56 @@ pub fn derive(item: DeriveInput) -> Result<TokenStream> {
3636
let mut to_sql_generics = item.generics.clone();
3737
to_sql_generics.params.push(parse_quote!(__DB));
3838
to_sql_generics.make_where_clause().predicates.push(parse_quote!(__DB: diesel::backend::Backend));
39-
to_sql_generics.make_where_clause().predicates.push(parse_quote!(Self: ToSql<#sql_type, __DB>));
39+
to_sql_generics.make_where_clause().predicates.push(parse_quote!(Self: diesel::serialize::ToSql<#sql_type, __DB>));
4040
let (to_sql_impl_generics, _, to_sql_where_clause) = to_sql_generics.split_for_impl();
4141

4242
let tokens = quote!(
43-
impl #impl_generics AsExpression<#sql_type>
43+
impl #impl_generics diesel::expression::AsExpression<#sql_type>
4444
for &'__expr #struct_ty #where_clause
4545
{
46-
type Expression = Bound<#sql_type, Self>;
46+
type Expression = diesel::internal::derives::as_expression::Bound<#sql_type, Self>;
4747

48-
fn as_expression(self) -> <Self as AsExpression<#sql_type>>::Expression {
49-
Bound::new(self)
48+
fn as_expression(self) -> <Self as diesel::expression::AsExpression<#sql_type>>::Expression {
49+
diesel::internal::derives::as_expression::Bound::new(self)
5050
}
5151
}
5252

53-
impl #impl_generics AsExpression<Nullable<#sql_type>>
53+
impl #impl_generics diesel::expression::AsExpression<diesel::sql_types::Nullable<#sql_type>>
5454
for &'__expr #struct_ty #where_clause
5555
{
56-
type Expression = Bound<Nullable<#sql_type>, Self>;
56+
type Expression = diesel::internal::derives::as_expression::Bound<diesel::sql_types::Nullable<#sql_type>, Self>;
5757

58-
fn as_expression(self) -> <Self as AsExpression<Nullable<#sql_type>>>::Expression {
59-
Bound::new(self)
58+
fn as_expression(self) -> <Self as diesel::expression::AsExpression<diesel::sql_types::Nullable<#sql_type>>>::Expression {
59+
diesel::internal::derives::as_expression::Bound::new(self)
6060
}
6161
}
6262

63-
impl #impl_generics2 AsExpression<#sql_type>
63+
impl #impl_generics2 diesel::expression::AsExpression<#sql_type>
6464
for &'__expr2 &'__expr #struct_ty #where_clause2
6565
{
66-
type Expression = Bound<#sql_type, Self>;
66+
type Expression = diesel::internal::derives::as_expression::Bound<#sql_type, Self>;
6767

68-
fn as_expression(self) -> <Self as AsExpression<#sql_type>>::Expression {
69-
Bound::new(self)
68+
fn as_expression(self) -> <Self as diesel::expression::AsExpression<#sql_type>>::Expression {
69+
diesel::internal::derives::as_expression::Bound::new(self)
7070
}
7171
}
7272

73-
impl #impl_generics2 AsExpression<Nullable<#sql_type>>
73+
impl #impl_generics2 diesel::expression::AsExpression<diesel::sql_types::Nullable<#sql_type>>
7474
for &'__expr2 &'__expr #struct_ty #where_clause2
7575
{
76-
type Expression = Bound<Nullable<#sql_type>, Self>;
76+
type Expression = diesel::internal::derives::as_expression::Bound<diesel::sql_types::Nullable<#sql_type>, Self>;
7777

78-
fn as_expression(self) -> <Self as AsExpression<Nullable<#sql_type>>>::Expression {
79-
Bound::new(self)
78+
fn as_expression(self) -> <Self as diesel::expression::AsExpression<diesel::sql_types::Nullable<#sql_type>>>::Expression {
79+
diesel::internal::derives::as_expression::Bound::new(self)
8080
}
8181
}
8282

83-
impl #to_sql_impl_generics diesel::serialize::ToSql<Nullable<#sql_type>, __DB>
83+
impl #to_sql_impl_generics diesel::serialize::ToSql<diesel::sql_types::Nullable<#sql_type>, __DB>
8484
for #struct_ty #to_sql_where_clause
8585
{
86-
fn to_sql<'__b>(&'__b self, out: &mut Output<'__b, '_, __DB>) -> serialize::Result
86+
fn to_sql<'__b>(&'__b self, out: &mut diesel::serialize::Output<'__b, '_, __DB>) -> diesel::serialize::Result
8787
{
88-
ToSql::<#sql_type, __DB>::to_sql(self, out)
88+
diesel::serialize::ToSql::<#sql_type, __DB>::to_sql(self, out)
8989
}
9090
}
9191
);
@@ -96,31 +96,28 @@ pub fn derive(item: DeriveInput) -> Result<TokenStream> {
9696
quote!(
9797
#tokens
9898

99-
impl #impl_generics_plain AsExpression<#sql_type> for #struct_ty #where_clause_plain {
100-
type Expression = Bound<#sql_type, Self>;
99+
impl #impl_generics_plain diesel::expression::AsExpression<#sql_type> for #struct_ty #where_clause_plain {
100+
type Expression = diesel::internal::derives::as_expression::Bound<#sql_type, Self>;
101101

102-
fn as_expression(self) -> <Self as AsExpression<#sql_type>>::Expression {
103-
Bound::new(self)
102+
fn as_expression(self) -> <Self as diesel::expression::AsExpression<#sql_type>>::Expression {
103+
diesel::internal::derives::as_expression::Bound::new(self)
104104
}
105105
}
106106

107-
impl #impl_generics_plain AsExpression<Nullable<#sql_type>> for #struct_ty #where_clause_plain {
108-
type Expression = Bound<Nullable<#sql_type>, Self>;
107+
impl #impl_generics_plain diesel::expression::AsExpression<diesel::sql_types::Nullable<#sql_type>> for #struct_ty
108+
#where_clause_plain
109+
{
110+
type Expression = diesel::internal::derives::as_expression::Bound<diesel::sql_types::Nullable<#sql_type>, Self>;
109111

110-
fn as_expression(self) -> <Self as AsExpression<Nullable<#sql_type>>>::Expression {
111-
Bound::new(self)
112+
fn as_expression(self) -> <Self as diesel::expression::AsExpression<diesel::sql_types::Nullable<#sql_type>>>::Expression {
113+
diesel::internal::derives::as_expression::Bound::new(self)
112114
}
113115
}
114116
)
115117
}
116118
});
117119

118120
Ok(wrap_in_dummy_mod(quote! {
119-
use diesel::expression::AsExpression;
120-
use diesel::internal::derives::as_expression::Bound;
121-
use diesel::sql_types::Nullable;
122-
use diesel::serialize::{self, ToSql, Output};
123-
124121
#(#tokens)*
125122
}))
126123
}

‎diesel_derives/src/from_sql_row.rs

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -23,20 +23,18 @@ pub fn derive(mut item: DeriveInput) -> Result<TokenStream> {
2323
.push(parse_quote!(__ST: diesel::sql_types::SingleValue));
2424
where_clause
2525
.predicates
26-
.push(parse_quote!(Self: FromSql<__ST, __DB>));
26+
.push(parse_quote!(Self: diesel::deserialize::FromSql<__ST, __DB>));
2727
}
2828
let (impl_generics, _, where_clause) = item.generics.split_for_impl();
2929

3030
Ok(wrap_in_dummy_mod(quote! {
31-
use diesel::deserialize::{self, FromSql, Queryable};
32-
3331
// Need to put __ST and __DB after lifetimes but before const params
34-
impl #impl_generics Queryable<__ST, __DB> for #struct_ty
32+
impl #impl_generics diesel::deserialize::Queryable<__ST, __DB> for #struct_ty
3533
#where_clause
3634
{
3735
type Row = Self;
3836

39-
fn build(row: <Self as Queryable<__ST, __DB>>::Row) -> deserialize::Result<Self> {
37+
fn build(row: Self) -> diesel::deserialize::Result<Self> {
4038
Ok(row)
4139
}
4240
}

‎diesel_derives/src/identifiable.rs

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -39,34 +39,32 @@ pub fn derive(item: DeriveInput) -> Result<TokenStream> {
3939
}
4040

4141
Ok(wrap_in_dummy_mod(quote! {
42-
use diesel::associations::{HasTable, Identifiable};
43-
44-
impl #impl_generics HasTable for #struct_name #ty_generics
42+
impl #impl_generics diesel::associations::HasTable for #struct_name #ty_generics
4543
#where_clause
4644
{
4745
type Table = #table_name::table;
4846

49-
fn table() -> Self::Table {
47+
fn table() -> <Self as diesel::associations::HasTable>::Table {
5048
#table_name::table
5149
}
5250
}
5351

54-
impl #ref_generics Identifiable for &'ident #struct_name #ty_generics
52+
impl #ref_generics diesel::associations::Identifiable for &'ident #struct_name #ty_generics
5553
#where_clause
5654
{
5755
type Id = (#(#field_ty),*);
5856

59-
fn id(self) -> Self::Id {
57+
fn id(self) -> <Self as diesel::associations::Identifiable>::Id {
6058
(#(#field_name),*)
6159
}
6260
}
6361

64-
impl #ref_generics Identifiable for &'_ &'ident #struct_name #ty_generics
62+
impl #ref_generics diesel::associations::Identifiable for &'_ &'ident #struct_name #ty_generics
6563
#where_clause
6664
{
6765
type Id = (#(#field_ty),*);
6866

69-
fn id(self) -> Self::Id {
67+
fn id(self) -> <Self as diesel::associations::Identifiable>::Id {
7068
(#(#field_name),*)
7169
}
7270
}

‎diesel_derives/src/insertable.rs

Lines changed: 24 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -19,10 +19,6 @@ pub fn derive(item: DeriveInput) -> Result<TokenStream> {
1919
.collect::<Result<Vec<_>>>()?;
2020

2121
Ok(wrap_in_dummy_mod(quote! {
22-
use diesel::insertable::Insertable;
23-
use diesel::internal::derives::insertable::UndecoratedInsertRecord;
24-
use diesel::prelude::*;
25-
2622
#(#tokens)*
2723
}))
2824
}
@@ -130,13 +126,13 @@ fn derive_into_single_table(
130126
}
131127

132128
let insert_owned = quote! {
133-
impl #impl_generics Insertable<#table_name::table> for #struct_name #ty_generics
129+
impl #impl_generics diesel::insertable::Insertable<#table_name::table> for #struct_name #ty_generics
134130
#where_clause
135131
{
136-
type Values = <(#(#direct_field_ty,)*) as Insertable<#table_name::table>>::Values;
132+
type Values = <(#(#direct_field_ty,)*) as diesel::insertable::Insertable<#table_name::table>>::Values;
137133

138-
fn values(self) -> <(#(#direct_field_ty,)*) as Insertable<#table_name::table>>::Values {
139-
(#(#direct_field_assign,)*).values()
134+
fn values(self) -> <(#(#direct_field_ty,)*) as diesel::insertable::Insertable<#table_name::table>>::Values {
135+
diesel::insertable::Insertable::<#table_name::table>::values((#(#direct_field_assign,)*))
140136
}
141137
}
142138
};
@@ -147,14 +143,14 @@ fn derive_into_single_table(
147143
let (impl_generics, ..) = impl_generics.split_for_impl();
148144

149145
quote! {
150-
impl #impl_generics Insertable<#table_name::table>
146+
impl #impl_generics diesel::insertable::Insertable<#table_name::table>
151147
for &'insert #struct_name #ty_generics
152148
#where_clause
153149
{
154-
type Values = <(#(#ref_field_ty,)*) as Insertable<#table_name::table>>::Values;
150+
type Values = <(#(#ref_field_ty,)*) as diesel::insertable::Insertable<#table_name::table>>::Values;
155151

156-
fn values(self) -> <(#(#ref_field_ty,)*) as Insertable<#table_name::table>>::Values {
157-
(#(#ref_field_assign,)*).values()
152+
fn values(self) -> <(#(#ref_field_ty,)*) as diesel::insertable::Insertable<#table_name::table>>::Values {
153+
diesel::insertable::Insertable::<#table_name::table>::values((#(#ref_field_assign,)*))
158154
}
159155
}
160156
}
@@ -167,7 +163,7 @@ fn derive_into_single_table(
167163

168164
#insert_borrowed
169165

170-
impl #impl_generics UndecoratedInsertRecord<#table_name::table>
166+
impl #impl_generics diesel::internal::derives::insertable::UndecoratedInsertRecord<#table_name::table>
171167
for #struct_name #ty_generics
172168
#where_clause
173169
{
@@ -224,14 +220,18 @@ fn field_expr_serialize_as(
224220
let column = quote!(#table_name::#column_name);
225221
if treat_none_as_default_value {
226222
if is_option_ty(ty) {
227-
Ok(quote!(::std::convert::Into::<#ty>::into(self.#field_name).map(|v| #column.eq(v))))
223+
Ok(
224+
quote!(::std::convert::Into::<#ty>::into(self.#field_name).map(|v| diesel::ExpressionMethods::eq(#column, v))),
225+
)
228226
} else {
229227
Ok(
230-
quote!(std::option::Option::Some(#column.eq(::std::convert::Into::<#ty>::into(self.#field_name)))),
228+
quote!(std::option::Option::Some(diesel::ExpressionMethods::eq(#column, ::std::convert::Into::<#ty>::into(self.#field_name)))),
231229
)
232230
}
233231
} else {
234-
Ok(quote!(#column.eq(::std::convert::Into::<#ty>::into(self.#field_name))))
232+
Ok(
233+
quote!(diesel::ExpressionMethods::eq(#column, ::std::convert::Into::<#ty>::into(self.#field_name))),
234+
)
235235
}
236236
}
237237

@@ -277,14 +277,18 @@ fn field_expr(
277277
if treat_none_as_default_value {
278278
if is_option_ty(&field.ty) {
279279
if lifetime.is_some() {
280-
Ok(quote!(self.#field_name.as_ref().map(|x| #column.eq(x))))
280+
Ok(
281+
quote!(self.#field_name.as_ref().map(|x| diesel::ExpressionMethods::eq(#column, x))),
282+
)
281283
} else {
282-
Ok(quote!(self.#field_name.map(|x| #column.eq(x))))
284+
Ok(quote!(self.#field_name.map(|x| diesel::ExpressionMethods::eq(#column, x))))
283285
}
284286
} else {
285-
Ok(quote!(std::option::Option::Some(#column.eq(#lifetime self.#field_name))))
287+
Ok(
288+
quote!(std::option::Option::Some(diesel::ExpressionMethods::eq(#column, #lifetime self.#field_name))),
289+
)
286290
}
287291
} else {
288-
Ok(quote!(#column.eq(#lifetime self.#field_name)))
292+
Ok(quote!(diesel::ExpressionMethods::eq(#column, #lifetime self.#field_name)))
289293
}
290294
}

‎diesel_derives/src/query_id.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,9 @@ use crate::util::wrap_in_dummy_mod;
77

88
pub fn derive(mut item: DeriveInput) -> TokenStream {
99
for ty_param in item.generics.type_params_mut() {
10-
ty_param.bounds.push(parse_quote!(QueryId));
10+
ty_param
11+
.bounds
12+
.push(parse_quote!(diesel::query_builder::QueryId));
1113
}
1214
let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
1315

@@ -22,16 +24,14 @@ pub fn derive(mut item: DeriveInput) -> TokenStream {
2224

2325
let query_id_ty_params = ty_params
2426
.iter()
25-
.map(|ty_param| quote!(<#ty_param as QueryId>::QueryId));
27+
.map(|ty_param| quote!(<#ty_param as diesel::query_builder::QueryId>::QueryId));
2628
let has_static_query_id = ty_params
2729
.iter()
28-
.map(|ty_param| quote!(<#ty_param as QueryId>::HAS_STATIC_QUERY_ID));
30+
.map(|ty_param| quote!(<#ty_param as diesel::query_builder::QueryId>::HAS_STATIC_QUERY_ID));
2931

3032
wrap_in_dummy_mod(quote! {
31-
use diesel::query_builder::QueryId;
32-
3333
#[allow(non_camel_case_types)]
34-
impl #impl_generics QueryId for #struct_name #ty_generics
34+
impl #impl_generics diesel::query_builder::QueryId for #struct_name #ty_generics
3535
#where_clause
3636
{
3737
type QueryId = #struct_name<#(#lifetimes,)* #(#query_id_ty_params,)*>;

0 commit comments

Comments
 (0)
Please sign in to comment.