Replace a bunch of quote! with quote_spanned!

Author: Keavon

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

@@ -28,13 +28,14 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 		..
 	} = parsed;
 
-	let category = &attributes.category.as_ref().map(|value| quote!(Some(#value))).unwrap_or(quote!(None));
+	let category = &attributes.category.as_ref().map(|value| quote_spanned!(value.span() => Some(#value))).unwrap_or(quote!(None));
 	let mod_name = format_ident!("_{}_mod", mod_name);
 
 	let display_name = match &attributes.display_name.as_ref() {
 		Some(lit) => lit.value(),
 		None => struct_name.to_string().to_case(Case::Title),
 	};
+	let struct_name_ident = struct_name;
 	let struct_name = format_ident!("{}Node", struct_name);
 
 	let struct_generics: Vec<Ident> = fields.iter().enumerate().map(|(i, _)| format_ident!("Node{}", i)).collect();
@@ -84,50 +85,50 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 	let field_types: Vec<_> = fields
 		.iter()
 		.map(|field| match field {
-			ParsedField::Regular { ty, .. } => ty.clone(),
+			ParsedField::Regular { ty, .. } => quote_spanned!(ty.span() => #ty),
 			ParsedField::Node { output_type, input_type, .. } => match parsed.is_async {
-				true => parse_quote!(&'n impl #graphene_core::Node<'n, #input_type, Output = impl core::future::Future<Output=#output_type>>),
-				false => parse_quote!(&'n impl #graphene_core::Node<'n, #input_type, Output = #output_type>),
+				true => quote_spanned!(output_type.span() => &'n impl #graphene_core::Node<'n, #input_type, Output = impl core::future::Future<Output=#output_type>>),
+				false => quote_spanned!(output_type.span() => &'n impl #graphene_core::Node<'n, #input_type, Output = #output_type>),
 			},
 		})
 		.collect();
 
 	let widget_override: Vec<_> = fields
 		.iter()
 		.map(|field| {
-			let parsed_widget_override = match field {
-				ParsedField::Regular { widget_override, .. } => widget_override,
-				ParsedField::Node { widget_override, .. } => widget_override,
+			let (parsed_widget_override, span) = match field {
+				ParsedField::Regular { widget_override, pat_ident, .. } => (widget_override, pat_ident.span()),
+				ParsedField::Node { widget_override, pat_ident, .. } => (widget_override, pat_ident.span()),
 			};
 			match parsed_widget_override {
-				ParsedWidgetOverride::None => quote!(RegistryWidgetOverride::None),
-				ParsedWidgetOverride::Hidden => quote!(RegistryWidgetOverride::Hidden),
-				ParsedWidgetOverride::String(lit_str) => quote!(RegistryWidgetOverride::String(#lit_str)),
-				ParsedWidgetOverride::Custom(lit_str) => quote!(RegistryWidgetOverride::Custom(#lit_str)),
+				ParsedWidgetOverride::None => quote_spanned!(span => RegistryWidgetOverride::None),
+				ParsedWidgetOverride::Hidden => quote_spanned!(span => RegistryWidgetOverride::Hidden),
+				ParsedWidgetOverride::String(lit_str) => quote_spanned!(lit_str.span() => RegistryWidgetOverride::String(#lit_str)),
+				ParsedWidgetOverride::Custom(lit_str) => quote_spanned!(lit_str.span() => RegistryWidgetOverride::Custom(#lit_str)),
 			}
 		})
 		.collect();
 
 	let value_sources: Vec<_> = fields
 		.iter()
 		.map(|field| match field {
-			ParsedField::Regular { value_source, .. } => match value_source {
-				ParsedValueSource::Default(data) => quote!(RegistryValueSource::Default(stringify!(#data))),
-				ParsedValueSource::Scope(data) => quote!(RegistryValueSource::Scope(#data)),
-				_ => quote!(RegistryValueSource::None),
+			ParsedField::Regular { value_source, pat_ident, .. } => match value_source {
+				ParsedValueSource::Default(data) => quote_spanned!(data.span() => RegistryValueSource::Default(stringify!(#data))),
+				ParsedValueSource::Scope(data) => quote_spanned!(data.span() => RegistryValueSource::Scope(#data)),
+				_ => quote_spanned!(pat_ident.span() => RegistryValueSource::None),
 			},
-			_ => quote!(RegistryValueSource::None),
+			ParsedField::Node { pat_ident, .. } => quote_spanned!(pat_ident.span() => RegistryValueSource::None),
 		})
 		.collect();
 
 	let default_types: Vec<_> = fields
 		.iter()
 		.map(|field| match field {
-			ParsedField::Regular { implementations, .. } => match implementations.first() {
-				Some(ty) => quote!(Some(concrete!(#ty))),
-				_ => quote!(None),
+			ParsedField::Regular { implementations, pat_ident, .. } => match implementations.first() {
+				Some(ty) => quote_spanned!(ty.span() => Some(concrete!(#ty))),
+				_ => quote_spanned!(pat_ident.span() => None),
 			},
-			_ => quote!(None),
+			ParsedField::Node { pat_ident, .. } => quote_spanned!(pat_ident.span() => None),
 		})
 		.collect();
 
@@ -167,19 +168,23 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 	let exposed: Vec<_> = fields
 		.iter()
 		.map(|field| match field {
-			ParsedField::Regular { exposed, .. } => quote!(#exposed),
-			_ => quote!(true),
+			ParsedField::Regular { exposed, pat_ident, .. } => quote_spanned!(pat_ident.span() => #exposed),
+			ParsedField::Node { pat_ident, .. } => quote_spanned!(pat_ident.span() => true),
 		})
 		.collect();
 
 	let eval_args = fields.iter().map(|field| match field {
 		ParsedField::Regular { pat_ident, .. } => {
 			let name = &pat_ident.ident;
-			quote! { let #name = self.#name.eval(__input.clone()).await; }
+			quote_spanned! { pat_ident.span() =>
+				let #name = self.#name.eval(__input.clone()).await;
+			}
 		}
 		ParsedField::Node { pat_ident, .. } => {
 			let name = &pat_ident.ident;
-			quote! { let #name = &self.#name; }
+			quote_spanned! { pat_ident.span() =>
+				let #name = &self.#name;
+			}
 		}
 	});
 
@@ -239,10 +244,10 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 				// Add Clampable bound if this field uses hard_min or hard_max
 				if number_hard_min.is_some() || number_hard_max.is_some() {
 					// The bound applies to the Output type of the future, which is #ty
-					clampable_clauses.push(quote!(#ty: #graphene_core::misc::Clampable));
+					clampable_clauses.push(quote_spanned!(ty.span() => #ty: #graphene_core::misc::Clampable));
 				}
 
-				quote!(
+				quote_spanned!(ty.span() =>
 					#fut_ident: core::future::Future<Output = #ty> + #graphene_core::WasmNotSend + 'n,
 					for<'all> #all_lifetime_ty: #graphene_core::WasmNotSend,
 					#name: #graphene_core::Node<'n, #input_type, Output = #fut_ident> + #graphene_core::WasmNotSync
@@ -253,7 +258,7 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 				let fut_ident = format_ident!("F{}", id);
 				future_idents.push(fut_ident.clone());
 
-				quote!(
+				quote_spanned!(output_type.span() =>
 					#fut_ident: core::future::Future<Output = #output_type> + #graphene_core::WasmNotSend + 'n,
 					#name: #graphene_core::Node<'n, #input_type, Output = #fut_ident > + #graphene_core::WasmNotSync
 				)
@@ -274,9 +279,7 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 	);
 	struct_where_clause.predicates.extend(extra_where);
 
-	let new_args = struct_generics.iter().zip(field_names.iter()).map(|(r#gen, name)| {
-		quote! { #name: #r#gen }
-	});
+	let new_args = struct_generics.iter().zip(field_names.iter()).map(|(r#gen, name)| quote_spanned!(name.span() => #name: #r#gen));
 
 	let async_keyword = is_async.then(|| quote!(async));
 	let await_keyword = is_async.then(|| quote!(.await));
@@ -295,18 +298,23 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
 		}
 	};
 	let path = match parsed.attributes.path {
-		Some(ref path) => quote!(stringify!(#path).replace(' ', "")),
+		Some(ref path) => quote_spanned!(path.span() => stringify!(#path).replace(' ', "")),
 		None => quote!(std::module_path!().rsplit_once("::").unwrap().0),
 	};
-	let identifier = quote!(format!("{}::{}", #path, stringify!(#struct_name)));
+	let identifier = quote_spanned!(struct_name_ident.span() => format!("{}::{}", #path, stringify!(#struct_name)));
 
 	let register_node_impl = generate_register_node_impl(parsed, &field_names, &struct_name, &identifier)?;
 	let import_name = format_ident!("_IMPORT_STUB_{}", mod_name.to_string().to_case(Case::UpperSnake));
 
-	let properties = &attributes.properties_string.as_ref().map(|value| quote!(Some(#value))).unwrap_or(quote!(None));
+	let properties = &attributes.properties_string.as_ref().map(|value| quote_spanned!(value.span() => Some(#value))).unwrap_or(quote!(None));
 
 	let node_input_accessor = generate_node_input_references(parsed, fn_generics, &field_idents, &graphene_core, &identifier);
-	Ok(quote! {
+
+	// ==========================
+	// MAIN CODE GENERATION BLOCK
+	// ==========================
+
+	Ok(quote_spanned! { parsed.fn_name.span() =>
 		/// Underlying implementation for [#struct_name]
 		#[inline]
 		#[allow(clippy::too_many_arguments)]
@@ -410,17 +418,17 @@ fn generate_node_input_references(parsed: &ParsedNodeFn, fn_generics: &[crate::G
 
 		// Only create structs with phantom data where necessary.
 		generated_input_accessor.push(if phantom_data_declerations.is_empty() {
-			quote! {
+			quote_spanned! { input_ident.span() =>
 				pub struct #struct_name;
 			}
 		} else {
-			quote! {
+			quote_spanned! { input_ident.span() =>
 				pub struct #struct_name <#(#used),*>{
 					#(#phantom_data_declerations,)*
 				}
 			}
 		});
-		generated_input_accessor.push(quote! {
+		generated_input_accessor.push(quote_spanned! { input_ident.span() =>
 			impl <#(#used),*> #graphene_core::NodeInputDecleration for #struct_name <#(#fn_generic_params),*> {
 				const INDEX: usize = #input_index;
 				fn identifier() -> &'static str {
@@ -457,14 +465,14 @@ fn generate_phantom_data<'a>(fn_generics: impl Iterator<Item = &'a crate::Generi
 			crate::GenericParam::Lifetime(lifetime_param) => {
 				let lifetime = &lifetime_param.lifetime;
 
-				fn_generic_params.push(quote! {#lifetime});
-				phantom_data_declerations.push(quote! {#field_name: core::marker::PhantomData<&#lifetime ()>})
+				fn_generic_params.push(quote_spanned!(lifetime.span() => #lifetime));
+				phantom_data_declerations.push(quote_spanned!(lifetime.span() => #field_name: core::marker::PhantomData<&#lifetime ()>))
 			}
 			crate::GenericParam::Type(type_param) => {
 				let generic_name = &type_param.ident;
 
-				fn_generic_params.push(quote! {#generic_name});
-				phantom_data_declerations.push(quote! {#field_name: core::marker::PhantomData<#generic_name>});
+				fn_generic_params.push(quote_spanned!(generic_name.span() => #generic_name));
+				phantom_data_declerations.push(quote_spanned!(generic_name.span() => #field_name: core::marker::PhantomData<#generic_name>));
 			}
 			_ => {}
 		}
@@ -523,21 +531,21 @@ fn generate_register_node_impl(parsed: &ParsedNodeFn, field_names: &[&Ident], st
 
 			let node = matches!(parsed.fields[j], ParsedField::Node { .. });
 
-			let downcast_node = quote!(
+			let downcast_node = quote_spanned!(field_name.span() =>
 				let #field_name: DowncastBothNode<#input_type, #output_type> = DowncastBothNode::new(args[#j].clone());
 			);
 			if node && !parsed.is_async {
 				return Err(Error::new_spanned(&parsed.fn_name, "Node needs to be async if you want to use lambda parameters"));
 			}
 			temp_constructors.push(downcast_node);
-			temp_node_io.push(quote!(fn_type_fut!(#input_type, #output_type, alias: #output_type)));
-			panic_node_types.push(quote!(#input_type, DynFuture<'static, #output_type>));
+			temp_node_io.push(quote_spanned!(output_type.span() => fn_type_fut!(#input_type, #output_type, alias: #output_type)));
+			panic_node_types.push(quote_spanned!(output_type.span() => #input_type, DynFuture<'static, #output_type>));
 		}
 		let input_type = match parsed.input.implementations.is_empty() {
 			true => parsed.input.ty.clone(),
 			false => parsed.input.implementations[i.min(parsed.input.implementations.len() - 1)].clone(),
 		};
-		constructors.push(quote!(
+		constructors.push(quote_spanned!(struct_name.span() =>
 			(
 				|args| {
 					Box::pin(async move {
@@ -580,6 +588,10 @@ fn generate_register_node_impl(parsed: &ParsedNodeFn, field_names: &[&Ident], st
 	})
 }
 
+// ========================
+// HELPER STRUCTS AND IMPLS
+// ========================
+
 use syn::visit_mut::VisitMut;
 use syn::{GenericArgument, Lifetime, Type};