Skip to content

Commit 44f34bc

Browse files
KeavonKeavon
committed
Use idiomatic formatting
1 parent fe15134 commit 44f34bc

File tree

2 files changed

+46
-46
lines changed

2 files changed

+46
-46
lines changed

‎node-graph/node-macro/src/codegen.rs

Lines changed: 40 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
2828
..
2929
} = parsed;
3030

31-
let category = &attributes.category.as_ref().map(|value| quote_spanned!(value.span() => Some(#value))).unwrap_or(quote!(None));
31+
let category = &attributes.category.as_ref().map(|value| quote_spanned!(value.span()=> Some(#value))).unwrap_or(quote!(None));
3232
let mod_name = format_ident!("_{}_mod", mod_name);
3333

3434
let display_name = match &attributes.display_name.as_ref() {
@@ -85,10 +85,10 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
8585
let field_types: Vec<_> = fields
8686
.iter()
8787
.map(|field| match field {
88-
ParsedField::Regular { ty, .. } => quote_spanned!(ty.span() => #ty),
88+
ParsedField::Regular { ty, .. } => quote_spanned!(ty.span()=> #ty),
8989
ParsedField::Node { output_type, input_type, .. } => match parsed.is_async {
90-
true => quote_spanned!(output_type.span() => &'n impl #graphene_core::Node<'n, #input_type, Output = impl core::future::Future<Output=#output_type>>),
91-
false => quote_spanned!(output_type.span() => &'n impl #graphene_core::Node<'n, #input_type, Output = #output_type>),
90+
true => quote_spanned!(output_type.span()=> &'n impl #graphene_core::Node<'n, #input_type, Output = impl core::future::Future<Output=#output_type>>),
91+
false => quote_spanned!(output_type.span()=> &'n impl #graphene_core::Node<'n, #input_type, Output = #output_type>),
9292
},
9393
})
9494
.collect();
@@ -101,10 +101,10 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
101101
ParsedField::Node { widget_override, pat_ident, .. } => (widget_override, pat_ident.span()),
102102
};
103103
match parsed_widget_override {
104-
ParsedWidgetOverride::None => quote_spanned!(span => RegistryWidgetOverride::None),
105-
ParsedWidgetOverride::Hidden => quote_spanned!(span => RegistryWidgetOverride::Hidden),
106-
ParsedWidgetOverride::String(lit_str) => quote_spanned!(lit_str.span() => RegistryWidgetOverride::String(#lit_str)),
107-
ParsedWidgetOverride::Custom(lit_str) => quote_spanned!(lit_str.span() => RegistryWidgetOverride::Custom(#lit_str)),
104+
ParsedWidgetOverride::None => quote_spanned!(span=> RegistryWidgetOverride::None),
105+
ParsedWidgetOverride::Hidden => quote_spanned!(span=> RegistryWidgetOverride::Hidden),
106+
ParsedWidgetOverride::String(lit_str) => quote_spanned!(lit_str.span()=> RegistryWidgetOverride::String(#lit_str)),
107+
ParsedWidgetOverride::Custom(lit_str) => quote_spanned!(lit_str.span()=> RegistryWidgetOverride::Custom(#lit_str)),
108108
}
109109
})
110110
.collect();
@@ -113,22 +113,22 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
113113
.iter()
114114
.map(|field| match field {
115115
ParsedField::Regular { value_source, pat_ident, .. } => match value_source {
116-
ParsedValueSource::Default(data) => quote_spanned!(data.span() => RegistryValueSource::Default(stringify!(#data))),
117-
ParsedValueSource::Scope(data) => quote_spanned!(data.span() => RegistryValueSource::Scope(#data)),
118-
_ => quote_spanned!(pat_ident.span() => RegistryValueSource::None),
116+
ParsedValueSource::Default(data) => quote_spanned!(data.span()=> RegistryValueSource::Default(stringify!(#data))),
117+
ParsedValueSource::Scope(data) => quote_spanned!(data.span()=> RegistryValueSource::Scope(#data)),
118+
_ => quote_spanned!(pat_ident.span()=> RegistryValueSource::None),
119119
},
120-
ParsedField::Node { pat_ident, .. } => quote_spanned!(pat_ident.span() => RegistryValueSource::None),
120+
ParsedField::Node { pat_ident, .. } => quote_spanned!(pat_ident.span()=> RegistryValueSource::None),
121121
})
122122
.collect();
123123

124124
let default_types: Vec<_> = fields
125125
.iter()
126126
.map(|field| match field {
127127
ParsedField::Regular { implementations, pat_ident, .. } => match implementations.first() {
128-
Some(ty) => quote_spanned!(ty.span() => Some(concrete!(#ty))),
129-
_ => quote_spanned!(pat_ident.span() => None),
128+
Some(ty) => quote_spanned!(ty.span()=> Some(concrete!(#ty))),
129+
_ => quote_spanned!(pat_ident.span()=> None),
130130
},
131-
ParsedField::Node { pat_ident, .. } => quote_spanned!(pat_ident.span() => None),
131+
ParsedField::Node { pat_ident, .. } => quote_spanned!(pat_ident.span()=> None),
132132
})
133133
.collect();
134134

@@ -168,21 +168,21 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
168168
let exposed: Vec<_> = fields
169169
.iter()
170170
.map(|field| match field {
171-
ParsedField::Regular { exposed, pat_ident, .. } => quote_spanned!(pat_ident.span() => #exposed),
172-
ParsedField::Node { pat_ident, .. } => quote_spanned!(pat_ident.span() => true),
171+
ParsedField::Regular { exposed, pat_ident, .. } => quote_spanned!(pat_ident.span()=> #exposed),
172+
ParsedField::Node { pat_ident, .. } => quote_spanned!(pat_ident.span()=> true),
173173
})
174174
.collect();
175175

176176
let eval_args = fields.iter().map(|field| match field {
177177
ParsedField::Regular { pat_ident, .. } => {
178178
let name = &pat_ident.ident;
179-
quote_spanned! { pat_ident.span() =>
179+
quote_spanned! {pat_ident.span()=>
180180
let #name = self.#name.eval(__input.clone()).await;
181181
}
182182
}
183183
ParsedField::Node { pat_ident, .. } => {
184184
let name = &pat_ident.ident;
185-
quote_spanned! { pat_ident.span() =>
185+
quote_spanned! {pat_ident.span()=>
186186
let #name = &self.#name;
187187
}
188188
}
@@ -198,13 +198,13 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
198198
let name = &pat_ident.ident;
199199
let mut tokens = quote!();
200200
if let Some(min) = number_hard_min {
201-
tokens.extend(quote_spanned! { min.span() =>
201+
tokens.extend(quote_spanned! {min.span()=>
202202
let #name = #graphene_core::misc::Clampable::clamp_hard_min(#name, #min);
203203
});
204204
}
205205

206206
if let Some(max) = number_hard_max {
207-
tokens.extend(quote_spanned! { max.span() =>
207+
tokens.extend(quote_spanned! {max.span()=>
208208
let #name = #graphene_core::misc::Clampable::clamp_hard_max(#name, #max);
209209
});
210210
}
@@ -244,10 +244,10 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
244244
// Add Clampable bound if this field uses hard_min or hard_max
245245
if number_hard_min.is_some() || number_hard_max.is_some() {
246246
// The bound applies to the Output type of the future, which is #ty
247-
clampable_clauses.push(quote_spanned!(ty.span() => #ty: #graphene_core::misc::Clampable));
247+
clampable_clauses.push(quote_spanned!(ty.span()=> #ty: #graphene_core::misc::Clampable));
248248
}
249249

250-
quote_spanned!(ty.span() =>
250+
quote_spanned!(ty.span()=>
251251
#fut_ident: core::future::Future<Output = #ty> + #graphene_core::WasmNotSend + 'n,
252252
for<'all> #all_lifetime_ty: #graphene_core::WasmNotSend,
253253
#name: #graphene_core::Node<'n, #input_type, Output = #fut_ident> + #graphene_core::WasmNotSync
@@ -258,7 +258,7 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
258258
let fut_ident = format_ident!("F{}", id);
259259
future_idents.push(fut_ident.clone());
260260

261-
quote_spanned!(output_type.span() =>
261+
quote_spanned!(output_type.span()=>
262262
#fut_ident: core::future::Future<Output = #output_type> + #graphene_core::WasmNotSend + 'n,
263263
#name: #graphene_core::Node<'n, #input_type, Output = #fut_ident > + #graphene_core::WasmNotSync
264264
)
@@ -279,7 +279,7 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
279279
);
280280
struct_where_clause.predicates.extend(extra_where);
281281

282-
let new_args = struct_generics.iter().zip(field_names.iter()).map(|(r#gen, name)| quote_spanned!(name.span() => #name: #r#gen));
282+
let new_args = struct_generics.iter().zip(field_names.iter()).map(|(r#gen, name)| quote_spanned!(name.span()=> #name: #r#gen));
283283

284284
let async_keyword = is_async.then(|| quote!(async));
285285
let await_keyword = is_async.then(|| quote!(.await));
@@ -298,23 +298,23 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
298298
}
299299
};
300300
let path = match parsed.attributes.path {
301-
Some(ref path) => quote_spanned!(path.span() => stringify!(#path).replace(' ', "")),
301+
Some(ref path) => quote_spanned!(path.span()=> stringify!(#path).replace(' ', "")),
302302
None => quote!(std::module_path!().rsplit_once("::").unwrap().0),
303303
};
304-
let identifier = quote_spanned!(struct_name_ident.span() => format!("{}::{}", #path, stringify!(#struct_name)));
304+
let identifier = quote_spanned!(struct_name_ident.span()=> format!("{}::{}", #path, stringify!(#struct_name)));
305305

306306
let register_node_impl = generate_register_node_impl(parsed, &field_names, &struct_name, &identifier)?;
307307
let import_name = format_ident!("_IMPORT_STUB_{}", mod_name.to_string().to_case(Case::UpperSnake));
308308

309-
let properties = &attributes.properties_string.as_ref().map(|value| quote_spanned!(value.span() => Some(#value))).unwrap_or(quote!(None));
309+
let properties = &attributes.properties_string.as_ref().map(|value| quote_spanned!(value.span()=> Some(#value))).unwrap_or(quote!(None));
310310

311311
let node_input_accessor = generate_node_input_references(parsed, fn_generics, &field_idents, &graphene_core, &identifier);
312312

313313
// ==========================
314314
// MAIN CODE GENERATION BLOCK
315315
// ==========================
316316

317-
Ok(quote_spanned! { parsed.fn_name.span() =>
317+
Ok(quote_spanned! {parsed.fn_name.span()=>
318318
/// Underlying implementation for [#struct_name]
319319
#[inline]
320320
#[allow(clippy::too_many_arguments)]
@@ -418,17 +418,17 @@ fn generate_node_input_references(parsed: &ParsedNodeFn, fn_generics: &[crate::G
418418

419419
// Only create structs with phantom data where necessary.
420420
generated_input_accessor.push(if phantom_data_declerations.is_empty() {
421-
quote_spanned! { input_ident.span() =>
421+
quote_spanned! {input_ident.span()=>
422422
pub struct #struct_name;
423423
}
424424
} else {
425-
quote_spanned! { input_ident.span() =>
425+
quote_spanned! {input_ident.span()=>
426426
pub struct #struct_name <#(#used),*>{
427427
#(#phantom_data_declerations,)*
428428
}
429429
}
430430
});
431-
generated_input_accessor.push(quote_spanned! { input_ident.span() =>
431+
generated_input_accessor.push(quote_spanned! {input_ident.span()=>
432432
impl <#(#used),*> #graphene_core::NodeInputDecleration for #struct_name <#(#fn_generic_params),*> {
433433
const INDEX: usize = #input_index;
434434
fn identifier() -> &'static str {
@@ -465,14 +465,14 @@ fn generate_phantom_data<'a>(fn_generics: impl Iterator<Item = &'a crate::Generi
465465
crate::GenericParam::Lifetime(lifetime_param) => {
466466
let lifetime = &lifetime_param.lifetime;
467467

468-
fn_generic_params.push(quote_spanned!(lifetime.span() => #lifetime));
469-
phantom_data_declerations.push(quote_spanned!(lifetime.span() => #field_name: core::marker::PhantomData<&#lifetime ()>))
468+
fn_generic_params.push(quote_spanned!(lifetime.span()=> #lifetime));
469+
phantom_data_declerations.push(quote_spanned!(lifetime.span()=> #field_name: core::marker::PhantomData<&#lifetime ()>))
470470
}
471471
crate::GenericParam::Type(type_param) => {
472472
let generic_name = &type_param.ident;
473473

474-
fn_generic_params.push(quote_spanned!(generic_name.span() => #generic_name));
475-
phantom_data_declerations.push(quote_spanned!(generic_name.span() => #field_name: core::marker::PhantomData<#generic_name>));
474+
fn_generic_params.push(quote_spanned!(generic_name.span()=> #generic_name));
475+
phantom_data_declerations.push(quote_spanned!(generic_name.span()=> #field_name: core::marker::PhantomData<#generic_name>));
476476
}
477477
_ => {}
478478
}
@@ -531,21 +531,21 @@ fn generate_register_node_impl(parsed: &ParsedNodeFn, field_names: &[&Ident], st
531531

532532
let node = matches!(parsed.fields[j], ParsedField::Node { .. });
533533

534-
let downcast_node = quote_spanned!(field_name.span() =>
534+
let downcast_node = quote_spanned!(field_name.span()=>
535535
let #field_name: DowncastBothNode<#input_type, #output_type> = DowncastBothNode::new(args[#j].clone());
536536
);
537537
if node && !parsed.is_async {
538538
return Err(Error::new_spanned(&parsed.fn_name, "Node needs to be async if you want to use lambda parameters"));
539539
}
540540
temp_constructors.push(downcast_node);
541-
temp_node_io.push(quote_spanned!(output_type.span() => fn_type_fut!(#input_type, #output_type, alias: #output_type)));
542-
panic_node_types.push(quote_spanned!(output_type.span() => #input_type, DynFuture<'static, #output_type>));
541+
temp_node_io.push(quote_spanned!(output_type.span()=> fn_type_fut!(#input_type, #output_type, alias: #output_type)));
542+
panic_node_types.push(quote_spanned!(output_type.span()=> #input_type, DynFuture<'static, #output_type>));
543543
}
544544
let input_type = match parsed.input.implementations.is_empty() {
545545
true => parsed.input.ty.clone(),
546546
false => parsed.input.implementations[i.min(parsed.input.implementations.len() - 1)].clone(),
547547
};
548-
constructors.push(quote_spanned!(struct_name.span() =>
548+
constructors.push(quote_spanned!(struct_name.span()=>
549549
(
550550
|args| {
551551
Box::pin(async move {

‎proc-macros/src/widget_builder.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -21,13 +21,13 @@ fn easier_string_assignment(field_ty: &Type, field_ident: &Ident) -> (TokenStrea
2121
// Based on https://stackoverflow.com/questions/66906261/rust-proc-macro-derive-how-do-i-check-if-a-field-is-of-a-primitive-type-like-b
2222
if last_segment.ident == Ident::new("String", last_segment.ident.span()) {
2323
return (
24-
quote::quote_spanned!(type_path.span() => impl Into<String>),
25-
quote::quote_spanned!(field_ident.span() => #field_ident.into()),
24+
quote::quote_spanned!(type_path.span()=> impl Into<String>),
25+
quote::quote_spanned!(field_ident.span()=> #field_ident.into()),
2626
);
2727
}
2828
}
2929
}
30-
(quote::quote_spanned!(field_ty.span() => #field_ty), quote::quote_spanned!(field_ident.span() => #field_ident))
30+
(quote::quote_spanned!(field_ty.span()=> #field_ty), quote::quote_spanned!(field_ident.span()=> #field_ident))
3131
}
3232

3333
/// Extract the identifier of the field (which should always be present)
@@ -54,8 +54,8 @@ fn find_type_and_assignment(field: &Field) -> syn::Result<(TokenStream2, TokenSt
5454
if let Some(first_generic) = generic_args.args.first() {
5555
if last_segment.ident == Ident::new("WidgetCallback", last_segment.ident.span()) {
5656
// Assign builder pattern to assign the closure directly
57-
function_input_ty = quote::quote_spanned!(field_ty.span() => impl Fn(&#first_generic) -> crate::messages::message::Message + 'static + Send + Sync);
58-
assignment = quote::quote_spanned!(field_ident.span() => crate::messages::layout::utility_types::layout_widget::WidgetCallback::new(#field_ident));
57+
function_input_ty = quote::quote_spanned!(field_ty.span()=> impl Fn(&#first_generic) -> crate::messages::message::Message + 'static + Send + Sync);
58+
assignment = quote::quote_spanned!(field_ident.span()=> crate::messages::layout::utility_types::layout_widget::WidgetCallback::new(#field_ident));
5959
}
6060
}
6161
}
@@ -78,7 +78,7 @@ fn construct_builder(field: &Field) -> syn::Result<TokenStream2> {
7878
let (function_input_ty, assignment) = find_type_and_assignment(field)?;
7979

8080
// Create builder function
81-
Ok(quote::quote_spanned!(field.span() =>
81+
Ok(quote::quote_spanned!(field.span()=>
8282
#[doc = #doc_comment]
8383
pub fn #field_ident(mut self, #field_ident: #function_input_ty) -> Self{
8484
self.#field_ident = #assignment;

0 commit comments

Comments
 (0)