fix: Replace quote! with quote_spanned! in #[program] macro

Replaces all uses of quote!{} with quote_spanned! in the program macro
code generation to ensure generated code corresponds to correct source
code locations. This enables the Rust compiler to report error messages
at the actual problematic code instead of the macro invocation.

Changes:
- Applied quote_spanned! to all 9 codegen files
- Added spanned variants of helper functions
- Proper span extraction at instruction, program, and module levels

Addresses issue #4015.

Author: AvhiMaz

lang/syn/src/codegen/program/accounts.rs

@@ -1,8 +1,10 @@
 use crate::Program;
 use heck::SnakeCase;
-use quote::quote;
+use quote::quote_spanned;
+use syn::spanned::Spanned;
 
 pub fn generate(program: &Program) -> proc_macro2::TokenStream {
+    let program_span = program.program_mod.span();
     let mut accounts = std::collections::HashMap::new();
 
     // Go through instruction accounts.
@@ -21,7 +23,7 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
         .iter()
         .map(|(macro_name, cfgs)| {
             let macro_name: proc_macro2::TokenStream = macro_name.parse().unwrap();
-            quote! {
+            quote_spanned! { program_span =>
                 #(#cfgs)*
                 pub use crate::#macro_name::*;
             }
@@ -31,7 +33,7 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
     // TODO: calculate the account size and add it as a constant field to
     //       each struct here. This is convenient for Rust clients.
 
-    quote! {
+    quote_spanned! { program_span =>
         /// An Anchor generated module, providing a set of structs
         /// mirroring the structs deriving `Accounts`, where each field is
         /// a `Pubkey`. This is useful for specifying accounts for a client.

lang/syn/src/codegen/program/common.rs

@@ -1,6 +1,6 @@
 use crate::IxArg;
 use heck::CamelCase;
-use quote::quote;
+use quote::quote_spanned;
 
 // Namespace for calculating instruction sighash signatures for any instruction
 // not affecting program state.
@@ -24,15 +24,23 @@ pub fn gen_discriminator(namespace: &str, name: impl ToString) -> proc_macro2::T
 }
 
 pub fn generate_ix_variant(name: &str, args: &[IxArg]) -> proc_macro2::TokenStream {
+    generate_ix_variant_spanned(name, args, proc_macro2::Span::call_site())
+}
+
+pub fn generate_ix_variant_spanned(
+    name: &str,
+    args: &[IxArg],
+    span: proc_macro2::Span,
+) -> proc_macro2::TokenStream {
     let ix_arg_names: Vec<&syn::Ident> = args.iter().map(|arg| &arg.name).collect();
-    let ix_name_camel = generate_ix_variant_name(name);
+    let ix_name_camel = generate_ix_variant_name_spanned(name, span);
 
     if args.is_empty() {
-        quote! {
+        quote_spanned! { span =>
             #ix_name_camel
         }
     } else {
-        quote! {
+        quote_spanned! { span =>
             #ix_name_camel {
                 #(#ix_arg_names),*
             }
@@ -44,3 +52,12 @@ pub fn generate_ix_variant_name(name: &str) -> proc_macro2::TokenStream {
     let n = name.to_camel_case();
     n.parse().unwrap()
 }
+
+pub fn generate_ix_variant_name_spanned(
+    name: &str,
+    span: proc_macro2::Span,
+) -> proc_macro2::TokenStream {
+    let n = name.to_camel_case();
+    let ident = proc_macro2::Ident::new(&n, span);
+    quote_spanned! { span => #ident }
+}

lang/syn/src/codegen/program/cpi.rs

@@ -1,9 +1,14 @@
-use crate::codegen::program::common::{generate_ix_variant, generate_ix_variant_name};
+use crate::codegen::program::common::{
+    generate_ix_variant_name_spanned, generate_ix_variant_spanned,
+};
 use crate::Program;
 use heck::SnakeCase;
-use quote::{quote, ToTokens};
+use quote::{quote_spanned, ToTokens};
+#[allow(unused_imports)]
+use syn::spanned::Spanned;
 
 pub fn generate(program: &Program) -> proc_macro2::TokenStream {
+    let program_span = program.program_mod.span();
     // Generate cpi methods for global methods.
     let global_cpi_methods: Vec<proc_macro2::TokenStream> = program
         .ixs
@@ -13,24 +18,25 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
             let cpi_method = {
                 let name = &ix.raw_method.sig.ident;
                 let name_str = name.to_string();
-                let ix_variant = generate_ix_variant(&name_str, &ix.args);
+                let ix_span = ix.raw_method.span();
+                let ix_variant = generate_ix_variant_spanned(&name_str, &ix.args, ix_span);
                 let method_name = &ix.ident;
                 let args: Vec<&syn::PatType> = ix.args.iter().map(|arg| &arg.raw_arg).collect();
                 let discriminator = {
-                    let name = generate_ix_variant_name(&name_str);
-                    quote! { <instruction::#name as anchor_lang::Discriminator>::DISCRIMINATOR }
+                    let name = generate_ix_variant_name_spanned(&name_str, ix_span);
+                    quote_spanned! { ix_span => <instruction::#name as anchor_lang::Discriminator>::DISCRIMINATOR }
                 };
                 let ret_type = &ix.returns.ty.to_token_stream();
                 let ix_cfgs = &ix.cfgs;
                 let (method_ret, maybe_return) = match ret_type.to_string().as_str() {
-                    "()" => (quote! {anchor_lang::Result<()> }, quote! { Ok(()) }),
+                    "()" => (quote_spanned! { ix_span => anchor_lang::Result<()> }, quote_spanned! { ix_span => Ok(()) }),
                     _ => (
-                        quote! { anchor_lang::Result<crate::cpi::Return::<#ret_type>> },
-                        quote! { Ok(crate::cpi::Return::<#ret_type> { phantom: crate::cpi::PhantomData }) }
+                        quote_spanned! { ix_span => anchor_lang::Result<crate::cpi::Return::<#ret_type>> },
+                        quote_spanned! { ix_span => Ok(crate::cpi::Return::<#ret_type> { phantom: crate::cpi::PhantomData }) }
                     )
                 };
 
-                quote! {
+                quote_spanned! { ix_span =>
                     #(#ix_cfgs)*
                     pub fn #method_name<'a, 'b, 'c, 'info>(
                         ctx: anchor_lang::context::CpiContext<'a, 'b, 'c, 'info, #accounts_ident<'info>>,
@@ -69,7 +75,7 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
 
     let accounts = generate_accounts(program);
 
-    quote! {
+    quote_spanned! { program_span =>
         #[cfg(feature = "cpi")]
         pub mod cpi {
             use super::*;
@@ -95,6 +101,7 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
 }
 
 pub fn generate_accounts(program: &Program) -> proc_macro2::TokenStream {
+    let program_span = program.program_mod.span();
     let mut accounts = std::collections::HashMap::new();
 
     // Go through instruction accounts.
@@ -114,14 +121,14 @@ pub fn generate_accounts(program: &Program) -> proc_macro2::TokenStream {
         .iter()
         .map(|(macro_name, cfgs)| {
             let macro_name: proc_macro2::TokenStream = macro_name.parse().unwrap();
-            quote! {
+            quote_spanned! { program_span =>
                 #(#cfgs)*
                 pub use crate::#macro_name::*;
             }
         })
         .collect();
 
-    quote! {
+    quote_spanned! { program_span =>
         /// An Anchor generated module, providing a set of structs
         /// mirroring the structs deriving `Accounts`, where each field is
         /// an `AccountInfo`. This is useful for CPI.

lang/syn/src/codegen/program/dispatch.rs

@@ -1,6 +1,7 @@
 use crate::Program;
 use heck::CamelCase;
-use quote::quote;
+use quote::quote_spanned;
+use syn::spanned::Spanned;
 
 pub fn generate(program: &Program) -> proc_macro2::TokenStream {
     // Dispatch all global instructions.
@@ -11,10 +12,12 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
             .to_camel_case()
             .parse()
             .expect("Failed to parse ix method name in camel as `TokenStream`");
-        let discriminator = quote! { instruction::#ix_name_camel::DISCRIMINATOR };
+        let ix_span = ix.raw_method.span();
+        let discriminator =
+            quote_spanned! { ix_span => instruction::#ix_name_camel::DISCRIMINATOR };
         let ix_cfgs = &ix.cfgs;
 
-        quote! {
+        quote_spanned! { ix_span =>
             #(#ix_cfgs)*
             if data.starts_with(#discriminator) {
                 return __private::__global::#ix_method_name(
@@ -27,9 +30,10 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
     });
 
     // Generate the event-cpi instruction handler based on whether the `event-cpi` feature is enabled.
+    let program_span = program.program_mod.span();
     let event_cpi_handler = {
         #[cfg(feature = "event-cpi")]
-        quote! {
+        quote_spanned! { program_span =>
             // `event-cpi` feature is enabled, dispatch self-cpi instruction
             __private::__events::__event_dispatch(
                 program_id,
@@ -38,7 +42,7 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
             )
         }
         #[cfg(not(feature = "event-cpi"))]
-        quote! {
+        quote_spanned! { program_span =>
             // `event-cpi` feature is not enabled
             Err(anchor_lang::error::ErrorCode::EventInstructionStub.into())
         }
@@ -50,17 +54,20 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
         .map(|fallback_fn| {
             let program_name = &program.name;
             let fn_name = &fallback_fn.raw_method.sig.ident;
-            quote! {
+            let fallback_span = fallback_fn.raw_method.span();
+            quote_spanned! { fallback_span =>
                 #program_name::#fn_name(program_id, accounts, data)
             }
         })
         .unwrap_or_else(|| {
-            quote! {
+            let program_span = program.program_mod.span();
+            quote_spanned! { program_span =>
                 Err(anchor_lang::error::ErrorCode::InstructionFallbackNotFound.into())
             }
         });
 
-    quote! {
+    let program_span = program.program_mod.span();
+    quote_spanned! { program_span =>
         /// Performs method dispatch.
         ///
         /// Each instruction's discriminator is checked until the given instruction data starts with

lang/syn/src/codegen/program/entry.rs

@@ -1,10 +1,12 @@
 use crate::Program;
 use heck::CamelCase;
-use quote::quote;
+use quote::quote_spanned;
+use syn::spanned::Spanned;
 
 pub fn generate(program: &Program) -> proc_macro2::TokenStream {
     let name: proc_macro2::TokenStream = program.name.to_string().to_camel_case().parse().unwrap();
-    quote! {
+    let span = program.program_mod.span();
+    quote_spanned! { span =>
         #[cfg(not(feature = "no-entrypoint"))]
         anchor_lang::solana_program::entrypoint!(entry);
         /// The Anchor codegen exposes a programming model where a user defines

lang/syn/src/codegen/program/handlers.rs

@@ -1,7 +1,8 @@
 use crate::codegen::program::common::*;
 use crate::program_codegen::idl::idl_accounts_and_functions;
 use crate::Program;
-use quote::{quote, ToTokens};
+use quote::{quote_spanned, ToTokens};
+use syn::spanned::Spanned;
 
 // Generate non-inlined wrappers for each instruction handler, since Solana's
 // BPF max stack size can't handle reasonable sized dispatch trees without doing
@@ -11,8 +12,9 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
     // A constant token stream that stores the accounts and functions, required to live
     // inside the target program in order to get the program ID.
     let idl_accounts_and_functions = idl_accounts_and_functions();
+    let program_span = program.program_mod.span();
     let non_inlined_idl: proc_macro2::TokenStream = {
-        quote! {
+        quote_spanned! { program_span =>
             // Entry for all IDL related instructions. Use the "no-idl" feature
             // to eliminate this code, for example, if one wants to make the
             // IDL no longer mutable or if one doesn't want to store the IDL
@@ -99,21 +101,23 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
             let ix_arg_names: Vec<&syn::Ident> = ix.args.iter().map(|arg| &arg.name).collect();
             let ix_method_name = &ix.raw_method.sig.ident;
             let ix_method_name_str = ix_method_name.to_string();
+            let ix_span = ix.raw_method.span();
             let ix_name = generate_ix_variant_name(&ix_method_name_str);
-            let variant_arm = generate_ix_variant(&ix_method_name_str, &ix.args);
+            let variant_arm = generate_ix_variant_spanned(&ix_method_name_str, &ix.args, ix_span);
             let ix_name_log = format!("Instruction: {ix_name}");
             let anchor = &ix.anchor_ident;
             let ret_type = &ix.returns.ty.to_token_stream();
             let cfgs = &ix.cfgs;
+            let ix_span = ix.raw_method.span();
             let maybe_set_return_data = match ret_type.to_string().as_str() {
-                "()" => quote! {},
-                _ => quote! {
+                "()" => quote_spanned! { ix_span => {} },
+                _ => quote_spanned! { ix_span => {
                     let mut return_data = Vec::with_capacity(256);
                     result.serialize(&mut return_data).unwrap();
                     anchor_lang::solana_program::program::set_return_data(&return_data);
-                },
+                }},
             };
-            quote! {
+            quote_spanned! { ix_span =>
                 #(#cfgs)*
                 #[inline(never)]
                 pub fn #ix_method_name<'info>(
@@ -165,7 +169,7 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
         })
         .collect();
 
-    quote! {
+    quote_spanned! { program_span =>
         /// Create a private module to not clutter the program's namespace.
         /// Defines an entrypoint for each individual instruction handler
         /// wrapper.
@@ -197,8 +201,9 @@ fn generate_event_cpi_mod() -> proc_macro2::TokenStream {
     {
         let authority = crate::parser::accounts::event_cpi::EventAuthority::get();
         let authority_name = authority.name;
+        let span = proc_macro2::Span::call_site();
 
-        quote! {
+        quote_spanned! { span =>
             /// __events mod defines handler for self-cpi based event logging
             pub mod __events {
                 use super::*;
@@ -231,5 +236,8 @@ fn generate_event_cpi_mod() -> proc_macro2::TokenStream {
         }
     }
     #[cfg(not(feature = "event-cpi"))]
-    quote! {}
+    {
+        let span = proc_macro2::Span::call_site();
+        quote_spanned! { span => }
+    }
 }

lang/syn/src/codegen/program/idl.rs

@@ -1,7 +1,8 @@
-use quote::quote;
+use quote::quote_spanned;
 
 pub fn idl_accounts_and_functions() -> proc_macro2::TokenStream {
-    quote! {
+    let span = proc_macro2::Span::call_site();
+    quote_spanned! { span =>
         use anchor_lang::idl::ERASED_AUTHORITY;
 
         #[account("internal")]

lang/syn/src/codegen/program/instruction.rs

@@ -2,9 +2,11 @@ use crate::codegen::program::common::*;
 use crate::parser;
 use crate::Program;
 use heck::CamelCase;
-use quote::quote;
+use quote::quote_spanned;
+use syn::spanned::Spanned;
 
 pub fn generate(program: &Program) -> proc_macro2::TokenStream {
+    let program_span = program.program_mod.span();
     let variants: Vec<proc_macro2::TokenStream> = program
         .ixs
         .iter()
@@ -33,8 +35,9 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
                         _ => gen_discriminator(SIGHASH_GLOBAL_NAMESPACE, name),
                     },
                 };
+                let ix_span = ix.raw_method.span();
 
-                quote! {
+                quote_spanned! { ix_span =>
                     #(#ix_cfgs)*
                     impl anchor_lang::Discriminator for #ix_name_camel {
                         const DISCRIMINATOR: &'static [u8] = #discriminator;
@@ -50,8 +53,9 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
                 }
             };
             // If no args, output a "unit" variant instead of a struct variant.
+            let ix_span = ix.raw_method.span();
             if ix.args.is_empty() {
-                quote! {
+                quote_spanned! { ix_span =>
                     #(#ix_cfgs)*
                     /// Instruction.
                     #[derive(AnchorSerialize, AnchorDeserialize)]
@@ -60,7 +64,7 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
                     #impls
                 }
             } else {
-                quote! {
+                quote_spanned! { ix_span =>
                     #(#ix_cfgs)*
                     /// Instruction.
                     #[derive(AnchorSerialize, AnchorDeserialize)]
@@ -74,7 +78,7 @@ pub fn generate(program: &Program) -> proc_macro2::TokenStream {
         })
         .collect();
 
-    quote! {
+    quote_spanned! { program_span =>
         /// An Anchor generated module containing the program's set of
         /// instructions, where each method handler in the `#[program]` mod is
         /// associated with a struct defining the input arguments to the