project-serum
/
anchor
mirror of https://github.com/project-serum/anchor.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

lang/syn: Rename rpc -> ix

This commit is contained in:
Armani Ferrante 2021-02-11 14:35:23 +08:00
parent 5aeb288b51
commit 4980d8ab3f
No known key found for this signature in database
GPG Key ID: D597A80BCF8E12B7
4 changed files with 133 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

214
lang/syn/src/codegen/program.rs
View File

@ -1,5 +1,5 @@
use crate::parser; use crate::parser;
use crate::{Program, RpcArg, State}; use crate::{IxArg, Program, State};
use heck::{CamelCase, SnakeCase}; use heck::{CamelCase, SnakeCase};
use quote::quote; use quote::quote;
@ -15,7 +15,7 @@ pub fn generate(program: Program) -> proc_macro2::TokenStream {
let dispatch = generate_dispatch(&program); let dispatch = generate_dispatch(&program);
let handlers_non_inlined = generate_non_inlined_handlers(&program); let handlers_non_inlined = generate_non_inlined_handlers(&program);
let methods = generate_methods(&program); let methods = generate_methods(&program);
let instructions = generate_instructions(&program); let ixs = generate_ixs(&program);
let cpi = generate_cpi(&program); let cpi = generate_cpi(&program);
let accounts = generate_accounts(&program); let accounts = generate_accounts(&program);
@ -26,22 +26,22 @@ pub fn generate(program: Program) -> proc_macro2::TokenStream {
#[cfg(not(feature = "no-entrypoint"))] #[cfg(not(feature = "no-entrypoint"))]
anchor_lang::solana_program::entrypoint!(entry); anchor_lang::solana_program::entrypoint!(entry);
#[cfg(not(feature = "no-entrypoint"))] #[cfg(not(feature = "no-entrypoint"))]
fn entry(program_id: &Pubkey, accounts: &[AccountInfo], instruction_data: &[u8]) -> ProgramResult { fn entry(program_id: &Pubkey, accounts: &[AccountInfo], ix_data: &[u8]) -> ProgramResult {
if instruction_data.len() < 8 { if ix_data.len() < 8 {
return Err(ProgramError::Custom(99)); return Err(ProgramError::Custom(99));
} }
let mut instruction_data: &[u8] = instruction_data; let mut ix_data: &[u8] = ix_data;
let sighash: [u8; 8] = { let sighash: [u8; 8] = {
let mut sighash: [u8; 8] = [0; 8]; let mut sighash: [u8; 8] = [0; 8];
sighash.copy_from_slice(&instruction_data[..8]); sighash.copy_from_slice(&ix_data[..8]);
instruction_data = &instruction_data[8..]; ix_data = &ix_data[8..];
sighash sighash
}; };
if cfg!(not(feature = "no-idl")) { if cfg!(not(feature = "no-idl")) {
if sighash == anchor_lang::idl::IDL_IX_TAG.to_le_bytes() { if sighash == anchor_lang::idl::IDL_IX_TAG.to_le_bytes() {
return __private::__idl(program_id, accounts, &instruction_data); return __private::__idl(program_id, accounts, &ix_data);
} }
} }
@ -57,7 +57,7 @@ pub fn generate(program: Program) -> proc_macro2::TokenStream {
#accounts #accounts
#instructions #ixs
#methods #methods
@ -81,7 +81,7 @@ pub fn generate_dispatch(program: &Program) -> proc_macro2::TokenStream {
format!("{:?}", sighash_arr).parse().unwrap(); format!("{:?}", sighash_arr).parse().unwrap();
quote! { quote! {
#sighash_tts => { #sighash_tts => {
let ix = instruction::#ix_name::deserialize(&mut instruction_data) let ix = instruction::#ix_name::deserialize(&mut ix_data)
.map_err(|_| ProgramError::Custom(1))?; // todo: error code .map_err(|_| ProgramError::Custom(1))?; // todo: error code
let instruction::#variant_arm = ix; let instruction::#variant_arm = ix;
__private::__ctor(program_id, accounts, #(#ctor_args),*) __private::__ctor(program_id, accounts, #(#ctor_args),*)
@ -100,28 +100,28 @@ pub fn generate_dispatch(program: &Program) -> proc_macro2::TokenStream {
.map(|(_impl_block, methods)| { .map(|(_impl_block, methods)| {
methods methods
.iter() .iter()
.map(|rpc: &crate::StateRpc| { .map(|ix: &crate::StateIx| {
let rpc_arg_names: Vec<&syn::Ident> = let ix_arg_names: Vec<&syn::Ident> =
rpc.args.iter().map(|arg| &arg.name).collect(); ix.args.iter().map(|arg| &arg.name).collect();
let name = &rpc.raw_method.sig.ident.to_string(); let name = &ix.raw_method.sig.ident.to_string();
let rpc_name: proc_macro2::TokenStream = let ix_method_name: proc_macro2::TokenStream =
{ format!("__{}", name).parse().unwrap() }; { format!("__{}", name).parse().unwrap() };
let variant_arm = generate_ix_variant( let variant_arm = generate_ix_variant(
rpc.raw_method.sig.ident.to_string(), ix.raw_method.sig.ident.to_string(),
&rpc.args, &ix.args,
true, true,
); );
let ix_name = let ix_name =
generate_ix_variant_name(rpc.raw_method.sig.ident.to_string(), true); generate_ix_variant_name(ix.raw_method.sig.ident.to_string(), true);
let sighash_arr = sighash(SIGHASH_STATE_NAMESPACE, &name); let sighash_arr = sighash(SIGHASH_STATE_NAMESPACE, &name);
let sighash_tts: proc_macro2::TokenStream = let sighash_tts: proc_macro2::TokenStream =
format!("{:?}", sighash_arr).parse().unwrap(); format!("{:?}", sighash_arr).parse().unwrap();
quote! { quote! {
#sighash_tts => { #sighash_tts => {
let ix = instruction::#ix_name::deserialize(&mut instruction_data) let ix = instruction::#ix_name::deserialize(&mut ix_data)
.map_err(|_| ProgramError::Custom(1))?; // todo: error code .map_err(|_| ProgramError::Custom(1))?; // todo: error code
let instruction::#variant_arm = ix; let instruction::#variant_arm = ix;
__private::#rpc_name(program_id, accounts, #(#rpc_arg_names),*) __private::#ix_method_name(program_id, accounts, #(#ix_arg_names),*)
} }
} }
}) })
@ -143,15 +143,15 @@ pub fn generate_dispatch(program: &Program) -> proc_macro2::TokenStream {
iface iface
.methods .methods
.iter() .iter()
.map(|m: &crate::StateRpc| { .map(|m: &crate::StateIx| {
let rpc_arg_names: Vec<&syn::Ident> = let ix_arg_names: Vec<&syn::Ident> =
m.args.iter().map(|arg| &arg.name).collect(); m.args.iter().map(|arg| &arg.name).collect();
let name = &m.raw_method.sig.ident.to_string(); let name = &m.raw_method.sig.ident.to_string();
let rpc_name: proc_macro2::TokenStream = format!("__{}_{}", iface.trait_name, name).parse().unwrap(); let ix_name: proc_macro2::TokenStream = format!("__{}_{}", iface.trait_name, name).parse().unwrap();
let raw_args: Vec<&syn::PatType> = m let raw_args: Vec<&syn::PatType> = m
.args .args
.iter() .iter()
.map(|arg: &crate::RpcArg| &arg.raw_arg) .map(|arg: &crate::IxArg| &arg.raw_arg)
.collect(); .collect();
let sighash_arr = sighash(&iface.trait_name, &m.ident.to_string()); let sighash_arr = sighash(&iface.trait_name, &m.ident.to_string());
let sighash_tts: proc_macro2::TokenStream = let sighash_tts: proc_macro2::TokenStream =
@ -174,12 +174,12 @@ pub fn generate_dispatch(program: &Program) -> proc_macro2::TokenStream {
quote! { quote! {
#sighash_tts => { #sighash_tts => {
#args_struct #args_struct
let ix = Args::deserialize(&mut instruction_data) let ix = Args::deserialize(&mut ix_data)
.map_err(|_| ProgramError::Custom(1))?; // todo: error code .map_err(|_| ProgramError::Custom(1))?; // todo: error code
let Args { let Args {
#(#rpc_arg_names),* #(#ix_arg_names),*
} = ix; } = ix;
__private::#rpc_name(program_id, accounts, #(#rpc_arg_names),*) __private::#ix_name(program_id, accounts, #(#ix_arg_names),*)
} }
} }
}) })
@ -192,23 +192,23 @@ pub fn generate_dispatch(program: &Program) -> proc_macro2::TokenStream {
// Dispatch all global instructions. // Dispatch all global instructions.
let dispatch_arms: Vec<proc_macro2::TokenStream> = program let dispatch_arms: Vec<proc_macro2::TokenStream> = program
.rpcs .ixs
.iter() .iter()
.map(|rpc| { .map(|ix| {
let rpc_arg_names: Vec<&syn::Ident> = rpc.args.iter().map(|arg| &arg.name).collect(); let ix_arg_names: Vec<&syn::Ident> = ix.args.iter().map(|arg| &arg.name).collect();
let rpc_name = &rpc.raw_method.sig.ident; let ix_method_name = &ix.raw_method.sig.ident;
let ix_name = generate_ix_variant_name(rpc.raw_method.sig.ident.to_string(), false); let ix_name = generate_ix_variant_name(ix.raw_method.sig.ident.to_string(), false);
let sighash_arr = sighash(SIGHASH_GLOBAL_NAMESPACE, &rpc_name.to_string()); let sighash_arr = sighash(SIGHASH_GLOBAL_NAMESPACE, &ix_method_name.to_string());
let sighash_tts: proc_macro2::TokenStream = let sighash_tts: proc_macro2::TokenStream =
format!("{:?}", sighash_arr).parse().unwrap(); format!("{:?}", sighash_arr).parse().unwrap();
let variant_arm = let variant_arm =
generate_ix_variant(rpc.raw_method.sig.ident.to_string(), &rpc.args, false); generate_ix_variant(ix.raw_method.sig.ident.to_string(), &ix.args, false);
quote! { quote! {
#sighash_tts => { #sighash_tts => {
let ix = instruction::#ix_name::deserialize(&mut instruction_data) let ix = instruction::#ix_name::deserialize(&mut ix_data)
.map_err(|_| ProgramError::Custom(1))?; // todo: error code .map_err(|_| ProgramError::Custom(1))?; // todo: error code
let instruction::#variant_arm = ix; let instruction::#variant_arm = ix;
__private::#rpc_name(program_id, accounts, #(#rpc_arg_names),*) __private::#ix_method_name(program_id, accounts, #(#ix_arg_names),*)
} }
} }
}) })
@ -450,23 +450,23 @@ pub fn generate_non_inlined_handlers(program: &Program) -> proc_macro2::TokenStr
.map(|(_impl_block, methods)| { .map(|(_impl_block, methods)| {
methods methods
.iter() .iter()
.map(|rpc| { .map(|ix| {
let rpc_params: Vec<_> = rpc.args.iter().map(|arg| &arg.raw_arg).collect(); let ix_params: Vec<_> = ix.args.iter().map(|arg| &arg.raw_arg).collect();
let rpc_arg_names: Vec<&syn::Ident> = let ix_arg_names: Vec<&syn::Ident> =
rpc.args.iter().map(|arg| &arg.name).collect(); ix.args.iter().map(|arg| &arg.name).collect();
let private_rpc_name: proc_macro2::TokenStream = { let private_ix_name: proc_macro2::TokenStream = {
let n = format!("__{}", &rpc.raw_method.sig.ident.to_string()); let n = format!("__{}", &ix.raw_method.sig.ident.to_string());
n.parse().unwrap() n.parse().unwrap()
}; };
let rpc_name = &rpc.raw_method.sig.ident; let ix_name = &ix.raw_method.sig.ident;
let state_ty: proc_macro2::TokenStream = state.name.parse().unwrap(); let state_ty: proc_macro2::TokenStream = state.name.parse().unwrap();
let anchor_ident = &rpc.anchor_ident; let anchor_ident = &ix.anchor_ident;
quote! { quote! {
#[inline(never)] #[inline(never)]
pub fn #private_rpc_name( pub fn #private_ix_name(
program_id: &Pubkey, program_id: &Pubkey,
accounts: &[AccountInfo], accounts: &[AccountInfo],
#(#rpc_params),* #(#ix_params),*
) -> ProgramResult { ) -> ProgramResult {
let mut remaining_accounts: &[AccountInfo] = accounts; let mut remaining_accounts: &[AccountInfo] = accounts;
@ -492,9 +492,9 @@ pub fn generate_non_inlined_handlers(program: &Program) -> proc_macro2::TokenStr
let ctx = Context::new(program_id, &mut accounts, remaining_accounts); let ctx = Context::new(program_id, &mut accounts, remaining_accounts);
// Execute user defined function. // Execute user defined function.
state.#rpc_name( state.#ix_name(
ctx, ctx,
#(#rpc_arg_names),* #(#ix_arg_names),*
)?; )?;
// Serialize the state and save it to storage. // Serialize the state and save it to storage.
@ -524,25 +524,25 @@ pub fn generate_non_inlined_handlers(program: &Program) -> proc_macro2::TokenStr
iface iface
.methods .methods
.iter() .iter()
.map(|rpc| { .map(|ix| {
let rpc_params: Vec<_> = rpc.args.iter().map(|arg| &arg.raw_arg).collect(); let ix_params: Vec<_> = ix.args.iter().map(|arg| &arg.raw_arg).collect();
let rpc_arg_names: Vec<&syn::Ident> = let ix_arg_names: Vec<&syn::Ident> =
rpc.args.iter().map(|arg| &arg.name).collect(); ix.args.iter().map(|arg| &arg.name).collect();
let private_rpc_name: proc_macro2::TokenStream = { let private_ix_name: proc_macro2::TokenStream = {
let n = format!("__{}_{}", iface.trait_name, &rpc.raw_method.sig.ident.to_string()); let n = format!("__{}_{}", iface.trait_name, &ix.raw_method.sig.ident.to_string());
n.parse().unwrap() n.parse().unwrap()
}; };
let rpc_name = &rpc.raw_method.sig.ident; let ix_name = &ix.raw_method.sig.ident;
let state_ty: proc_macro2::TokenStream = state.name.parse().unwrap(); let state_ty: proc_macro2::TokenStream = state.name.parse().unwrap();
let anchor_ident = &rpc.anchor_ident; let anchor_ident = &ix.anchor_ident;
if rpc.has_receiver { if ix.has_receiver {
quote! { quote! {
#[inline(never)] #[inline(never)]
pub fn #private_rpc_name( pub fn #private_ix_name(
program_id: &Pubkey, program_id: &Pubkey,
accounts: &[AccountInfo], accounts: &[AccountInfo],
#(#rpc_params),* #(#ix_params),*
) -> ProgramResult { ) -> ProgramResult {
let mut remaining_accounts: &[AccountInfo] = accounts; let mut remaining_accounts: &[AccountInfo] = accounts;
@ -568,9 +568,9 @@ pub fn generate_non_inlined_handlers(program: &Program) -> proc_macro2::TokenStr
let ctx = Context::new(program_id, &mut accounts, remaining_accounts); let ctx = Context::new(program_id, &mut accounts, remaining_accounts);
// Execute user defined function. // Execute user defined function.
state.#rpc_name( state.#ix_name(
ctx, ctx,
#(#rpc_arg_names),* #(#ix_arg_names),*
)?; )?;
// Serialize the state and save it to storage. // Serialize the state and save it to storage.
@ -587,19 +587,19 @@ pub fn generate_non_inlined_handlers(program: &Program) -> proc_macro2::TokenStr
let state_name: proc_macro2::TokenStream = state.name.parse().unwrap(); let state_name: proc_macro2::TokenStream = state.name.parse().unwrap();
quote! { quote! {
#[inline(never)] #[inline(never)]
pub fn #private_rpc_name( pub fn #private_ix_name(
program_id: &Pubkey, program_id: &Pubkey,
accounts: &[AccountInfo], accounts: &[AccountInfo],
#(#rpc_params),* #(#ix_params),*
) -> ProgramResult { ) -> ProgramResult {
let mut remaining_accounts: &[AccountInfo] = accounts; let mut remaining_accounts: &[AccountInfo] = accounts;
let mut accounts = #anchor_ident::try_accounts( let mut accounts = #anchor_ident::try_accounts(
program_id, program_id,
&mut remaining_accounts, &mut remaining_accounts,
)?; )?;
#state_name::#rpc_name( #state_name::#ix_name(
Context::new(program_id, &mut accounts, remaining_accounts), Context::new(program_id, &mut accounts, remaining_accounts),
#(#rpc_arg_names),* #(#ix_arg_names),*
)?; )?;
accounts.exit(program_id) accounts.exit(program_id)
} }
@ -613,26 +613,26 @@ pub fn generate_non_inlined_handlers(program: &Program) -> proc_macro2::TokenStr
.unwrap_or(Vec::new()), .unwrap_or(Vec::new()),
}; };
let non_inlined_handlers: Vec<proc_macro2::TokenStream> = program let non_inlined_handlers: Vec<proc_macro2::TokenStream> = program
.rpcs .ixs
.iter() .iter()
.map(|rpc| { .map(|ix| {
let rpc_params: Vec<_> = rpc.args.iter().map(|arg| &arg.raw_arg).collect(); let ix_params: Vec<_> = ix.args.iter().map(|arg| &arg.raw_arg).collect();
let rpc_arg_names: Vec<&syn::Ident> = rpc.args.iter().map(|arg| &arg.name).collect(); let ix_arg_names: Vec<&syn::Ident> = ix.args.iter().map(|arg| &arg.name).collect();
let rpc_name = &rpc.raw_method.sig.ident; let ix_name = &ix.raw_method.sig.ident;
let anchor = &rpc.anchor_ident; let anchor = &ix.anchor_ident;
quote! { quote! {
#[inline(never)] #[inline(never)]
pub fn #rpc_name( pub fn #ix_name(
program_id: &Pubkey, program_id: &Pubkey,
accounts: &[AccountInfo], accounts: &[AccountInfo],
#(#rpc_params),* #(#ix_params),*
) -> ProgramResult { ) -> ProgramResult {
let mut remaining_accounts: &[AccountInfo] = accounts; let mut remaining_accounts: &[AccountInfo] = accounts;
let mut accounts = #anchor::try_accounts(program_id, &mut remaining_accounts)?; let mut accounts = #anchor::try_accounts(program_id, &mut remaining_accounts)?;
#program_name::#rpc_name( #program_name::#ix_name(
Context::new(program_id, &mut accounts, remaining_accounts), Context::new(program_id, &mut accounts, remaining_accounts),
#(#rpc_arg_names),* #(#ix_arg_names),*
)?; )?;
accounts.exit(program_id) accounts.exit(program_id)
} }
@ -748,11 +748,11 @@ fn generate_ctor_args(state: &State) -> Vec<Box<syn::Pat>> {
pub fn generate_ix_variant( pub fn generate_ix_variant(
name: String, name: String,
args: &[RpcArg], args: &[IxArg],
underscore: bool, underscore: bool,
) -> proc_macro2::TokenStream { ) -> proc_macro2::TokenStream {
let rpc_arg_names: Vec<&syn::Ident> = args.iter().map(|arg| &arg.name).collect(); let ix_arg_names: Vec<&syn::Ident> = args.iter().map(|arg| &arg.name).collect();
let rpc_name_camel: proc_macro2::TokenStream = { let ix_name_camel: proc_macro2::TokenStream = {
let n = name.to_camel_case(); let n = name.to_camel_case();
if underscore { if underscore {
format!("__{}", n).parse().unwrap() format!("__{}", n).parse().unwrap()
@ -763,12 +763,12 @@ pub fn generate_ix_variant(
if args.len() == 0 { if args.len() == 0 {
quote! { quote! {
#rpc_name_camel #ix_name_camel
} }
} else { } else {
quote! { quote! {
#rpc_name_camel { #ix_name_camel {
#(#rpc_arg_names),* #(#ix_arg_names),*
} }
} }
} }
@ -790,7 +790,7 @@ pub fn generate_methods(program: &Program) -> proc_macro2::TokenStream {
} }
} }
pub fn generate_instructions(program: &Program) -> proc_macro2::TokenStream { pub fn generate_ixs(program: &Program) -> proc_macro2::TokenStream {
let ctor_variant = generate_ctor_typed_variant_with_semi(program); let ctor_variant = generate_ctor_typed_variant_with_semi(program);
let state_method_variants: Vec<proc_macro2::TokenStream> = match &program.state { let state_method_variants: Vec<proc_macro2::TokenStream> = match &program.state {
None => vec![], None => vec![],
@ -801,7 +801,7 @@ pub fn generate_instructions(program: &Program) -> proc_macro2::TokenStream {
methods methods
.iter() .iter()
.map(|method| { .map(|method| {
let rpc_name_camel: proc_macro2::TokenStream = { let ix_name_camel: proc_macro2::TokenStream = {
let name = format!( let name = format!(
"__{}", "__{}",
&method.raw_method.sig.ident.to_string().to_camel_case(), &method.raw_method.sig.ident.to_string().to_camel_case(),
@ -824,7 +824,7 @@ pub fn generate_instructions(program: &Program) -> proc_macro2::TokenStream {
let sighash_tts: proc_macro2::TokenStream = let sighash_tts: proc_macro2::TokenStream =
format!("{:?}", sighash_arr).parse().unwrap(); format!("{:?}", sighash_arr).parse().unwrap();
quote! { quote! {
impl anchor_lang::InstructionData for #rpc_name_camel { impl anchor_lang::InstructionData for #ix_name_camel {
fn data(&self) -> Vec<u8> { fn data(&self) -> Vec<u8> {
let mut d = #sighash_tts.to_vec(); let mut d = #sighash_tts.to_vec();
d.append(&mut self.try_to_vec().expect("Should always serialize")); d.append(&mut self.try_to_vec().expect("Should always serialize"));
@ -838,14 +838,14 @@ pub fn generate_instructions(program: &Program) -> proc_macro2::TokenStream {
if method.args.len() == 0 { if method.args.len() == 0 {
quote! { quote! {
#[derive(AnchorSerialize, AnchorDeserialize)] #[derive(AnchorSerialize, AnchorDeserialize)]
pub struct #rpc_name_camel; pub struct #ix_name_camel;
#ix_data_trait #ix_data_trait
} }
} else { } else {
quote! { quote! {
#[derive(AnchorSerialize, AnchorDeserialize)] #[derive(AnchorSerialize, AnchorDeserialize)]
pub struct #rpc_name_camel { pub struct #ix_name_camel {
#(#raw_args),* #(#raw_args),*
} }
@ -858,13 +858,13 @@ pub fn generate_instructions(program: &Program) -> proc_macro2::TokenStream {
.unwrap_or(Vec::new()), .unwrap_or(Vec::new()),
}; };
let variants: Vec<proc_macro2::TokenStream> = program let variants: Vec<proc_macro2::TokenStream> = program
.rpcs .ixs
.iter() .iter()
.map(|rpc| { .map(|ix| {
let name = &rpc.raw_method.sig.ident.to_string(); let name = &ix.raw_method.sig.ident.to_string();
let rpc_name_camel = let ix_name_camel =
proc_macro2::Ident::new(&name.to_camel_case(), rpc.raw_method.sig.ident.span()); proc_macro2::Ident::new(&name.to_camel_case(), ix.raw_method.sig.ident.span());
let raw_args: Vec<proc_macro2::TokenStream> = rpc let raw_args: Vec<proc_macro2::TokenStream> = ix
.args .args
.iter() .iter()
.map(|arg| { .map(|arg| {
@ -878,7 +878,7 @@ pub fn generate_instructions(program: &Program) -> proc_macro2::TokenStream {
let sighash_tts: proc_macro2::TokenStream = let sighash_tts: proc_macro2::TokenStream =
format!("{:?}", sighash_arr).parse().unwrap(); format!("{:?}", sighash_arr).parse().unwrap();
quote! { quote! {
impl anchor_lang::InstructionData for #rpc_name_camel { impl anchor_lang::InstructionData for #ix_name_camel {
fn data(&self) -> Vec<u8> { fn data(&self) -> Vec<u8> {
let mut d = #sighash_tts.to_vec(); let mut d = #sighash_tts.to_vec();
d.append(&mut self.try_to_vec().expect("Should always serialize")); d.append(&mut self.try_to_vec().expect("Should always serialize"));
@ -888,17 +888,17 @@ pub fn generate_instructions(program: &Program) -> proc_macro2::TokenStream {
} }
}; };
// If no args, output a "unit" variant instead of a struct variant. // If no args, output a "unit" variant instead of a struct variant.
if rpc.args.len() == 0 { if ix.args.len() == 0 {
quote! { quote! {
#[derive(AnchorSerialize, AnchorDeserialize)] #[derive(AnchorSerialize, AnchorDeserialize)]
pub struct #rpc_name_camel; pub struct #ix_name_camel;
#ix_data_trait #ix_data_trait
} }
} else { } else {
quote! { quote! {
#[derive(AnchorSerialize, AnchorDeserialize)] #[derive(AnchorSerialize, AnchorDeserialize)]
pub struct #rpc_name_camel { pub struct #ix_name_camel {
#(#raw_args),* #(#raw_args),*
} }
@ -929,8 +929,8 @@ fn generate_accounts(program: &Program) -> proc_macro2::TokenStream {
// Go through state accounts. // Go through state accounts.
if let Some(state) = &program.state { if let Some(state) = &program.state {
if let Some((_impl_block, methods)) = &state.impl_block_and_methods { if let Some((_impl_block, methods)) = &state.impl_block_and_methods {
for rpc in methods { for ix in methods {
let anchor_ident = &rpc.anchor_ident; let anchor_ident = &ix.anchor_ident;
// TODO: move to fn and share with accounts.rs. // TODO: move to fn and share with accounts.rs.
let macro_name = format!( let macro_name = format!(
"__client_accounts_{}", "__client_accounts_{}",
@ -942,8 +942,8 @@ fn generate_accounts(program: &Program) -> proc_macro2::TokenStream {
} }
// Go through instruction accounts. // Go through instruction accounts.
for rpc in &program.rpcs { for ix in &program.ixs {
let anchor_ident = &rpc.anchor_ident; let anchor_ident = &ix.anchor_ident;
// TODO: move to fn and share with accounts.rs. // TODO: move to fn and share with accounts.rs.
let macro_name = format!( let macro_name = format!(
"__client_accounts_{}", "__client_accounts_{}",
@ -978,16 +978,16 @@ fn generate_accounts(program: &Program) -> proc_macro2::TokenStream {
fn generate_cpi(program: &Program) -> proc_macro2::TokenStream { fn generate_cpi(program: &Program) -> proc_macro2::TokenStream {
let cpi_methods: Vec<proc_macro2::TokenStream> = program let cpi_methods: Vec<proc_macro2::TokenStream> = program
.rpcs .ixs
.iter() .iter()
.map(|rpc| { .map(|ix| {
let accounts_ident = &rpc.anchor_ident; let accounts_ident = &ix.anchor_ident;
let cpi_method = { let cpi_method = {
let ix_variant = let ix_variant =
generate_ix_variant(rpc.raw_method.sig.ident.to_string(), &rpc.args, false); generate_ix_variant(ix.raw_method.sig.ident.to_string(), &ix.args, false);
let method_name = &rpc.ident; let method_name = &ix.ident;
let args: Vec<&syn::PatType> = rpc.args.iter().map(|arg| &arg.raw_arg).collect(); let args: Vec<&syn::PatType> = ix.args.iter().map(|arg| &arg.raw_arg).collect();
let name = &rpc.raw_method.sig.ident.to_string(); let name = &ix.raw_method.sig.ident.to_string();
let sighash_arr = sighash(SIGHASH_GLOBAL_NAMESPACE, &name); let sighash_arr = sighash(SIGHASH_GLOBAL_NAMESPACE, &name);
let sighash_tts: proc_macro2::TokenStream = let sighash_tts: proc_macro2::TokenStream =
format!("{:?}", sighash_arr).parse().unwrap(); format!("{:?}", sighash_arr).parse().unwrap();

6
lang/syn/src/idl.rs
View File

@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
pub struct Idl { pub struct Idl {
pub version: String, pub version: String,
pub name: String, pub name: String,
pub instructions: Vec<IdlInstruction>, pub instructions: Vec<IdlIx>,
#[serde(skip_serializing_if = "Option::is_none", default)] #[serde(skip_serializing_if = "Option::is_none", default)]
pub state: Option<IdlState>, pub state: Option<IdlState>,
#[serde(skip_serializing_if = "Vec::is_empty", default)] #[serde(skip_serializing_if = "Vec::is_empty", default)]
@ -24,10 +24,10 @@ pub struct IdlState {
pub methods: Vec<IdlStateMethod>, pub methods: Vec<IdlStateMethod>,
} }
pub type IdlStateMethod = IdlInstruction; pub type IdlStateMethod = IdlIx;
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IdlInstruction { pub struct IdlIx {
pub name: String, pub name: String,
pub accounts: Vec<IdlAccountItem>, pub accounts: Vec<IdlAccountItem>,
pub args: Vec<IdlField>, pub args: Vec<IdlField>,

16
lang/syn/src/lib.rs
View File

@ -20,7 +20,7 @@ pub mod parser;
#[derive(Debug)] #[derive(Debug)]
pub struct Program { pub struct Program {
pub state: Option<State>, pub state: Option<State>,
pub rpcs: Vec<Rpc>, pub ixs: Vec<Ix>,
pub name: syn::Ident, pub name: syn::Ident,
pub program_mod: syn::ItemMod, pub program_mod: syn::ItemMod,
} }
@ -31,15 +31,15 @@ pub struct State {
pub name: String, pub name: String,
pub strct: syn::ItemStruct, pub strct: syn::ItemStruct,
pub ctor_and_anchor: Option<(syn::ImplItemMethod, syn::Ident)>, pub ctor_and_anchor: Option<(syn::ImplItemMethod, syn::Ident)>,
pub impl_block_and_methods: Option<(syn::ItemImpl, Vec<StateRpc>)>, pub impl_block_and_methods: Option<(syn::ItemImpl, Vec<StateIx>)>,
pub interfaces: Option<Vec<StateInterface>>, pub interfaces: Option<Vec<StateInterface>>,
} }
#[derive(Debug)] #[derive(Debug)]
pub struct StateRpc { pub struct StateIx {
pub raw_method: syn::ImplItemMethod, pub raw_method: syn::ImplItemMethod,
pub ident: syn::Ident, pub ident: syn::Ident,
pub args: Vec<RpcArg>, pub args: Vec<IxArg>,
pub anchor_ident: syn::Ident, pub anchor_ident: syn::Ident,
// True if there exists a &self on the method. // True if there exists a &self on the method.
pub has_receiver: bool, pub has_receiver: bool,
@ -48,20 +48,20 @@ pub struct StateRpc {
#[derive(Debug)] #[derive(Debug)]
pub struct StateInterface { pub struct StateInterface {
pub trait_name: String, pub trait_name: String,
pub methods: Vec<StateRpc>, pub methods: Vec<StateIx>,
} }
#[derive(Debug)] #[derive(Debug)]
pub struct Rpc { pub struct Ix {
pub raw_method: syn::ItemFn, pub raw_method: syn::ItemFn,
pub ident: syn::Ident, pub ident: syn::Ident,
pub args: Vec<RpcArg>, pub args: Vec<IxArg>,
// The ident for the struct deriving Accounts. // The ident for the struct deriving Accounts.
pub anchor_ident: syn::Ident, pub anchor_ident: syn::Ident,
} }
#[derive(Debug)] #[derive(Debug)]
pub struct RpcArg { pub struct IxArg {
pub name: proc_macro2::Ident, pub name: proc_macro2::Ident,
pub raw_arg: syn::PatType, pub raw_arg: syn::PatType,
} }

30
lang/syn/src/parser/program.rs
View File

@ -1,5 +1,5 @@
use crate::parser; use crate::parser;
use crate::{Program, Rpc, RpcArg, State, StateInterface, StateRpc}; use crate::{Ix, IxArg, Program, State, StateInterface, StateIx};
const STATE_STRUCT_ATTRIBUTE: &str = "state"; const STATE_STRUCT_ATTRIBUTE: &str = "state";
@ -49,7 +49,7 @@ pub fn parse(program_mod: syn::ItemMod) -> Program {
}) })
.next(), .next(),
}; };
// Parse ctor and the type in `Context<MY-TYPE>`. // Parse ctor and the generic type in `Context<MY-TYPE>`.
let ctor_and_anchor = match &impl_block { let ctor_and_anchor = match &impl_block {
None => None, None => None,
Some(impl_block) => { Some(impl_block) => {
@ -77,7 +77,7 @@ pub fn parse(program_mod: syn::ItemMod) -> Program {
} }
}; };
// Parse all methods in the above `impl` block. // Parse all methods in the above `impl` block.
let methods: Option<Vec<StateRpc>> = impl_block.as_ref().map(|impl_block| { let methods: Option<Vec<StateIx>> = impl_block.as_ref().map(|impl_block| {
impl_block impl_block
.items .items
.iter() .iter()
@ -100,17 +100,17 @@ pub fn parse(program_mod: syn::ItemMod) -> Program {
syn::Pat::Ident(ident) => &ident.ident, syn::Pat::Ident(ident) => &ident.ident,
_ => panic!("invalid syntax"), _ => panic!("invalid syntax"),
}; };
RpcArg { IxArg {
name: ident.clone(), name: ident.clone(),
raw_arg: raw_arg.clone(), raw_arg: raw_arg.clone(),
} }
}) })
.collect::<Vec<RpcArg>>(); .collect::<Vec<IxArg>>();
// Remove the Anchor accounts argument // Remove the Anchor accounts argument
let anchor = args.remove(0); let anchor = args.remove(0);
let anchor_ident = extract_ident(&anchor.raw_arg).clone(); let anchor_ident = extract_ident(&anchor.raw_arg).clone();
Some(StateRpc { Some(StateIx {
raw_method: m.clone(), raw_method: m.clone(),
ident: m.sig.ident.clone(), ident: m.sig.ident.clone(),
args, args,
@ -168,17 +168,17 @@ pub fn parse(program_mod: syn::ItemMod) -> Program {
syn::Pat::Ident(ident) => &ident.ident, syn::Pat::Ident(ident) => &ident.ident,
_ => panic!("invalid syntax"), _ => panic!("invalid syntax"),
}; };
RpcArg { IxArg {
name: ident.clone(), name: ident.clone(),
raw_arg: raw_arg.clone(), raw_arg: raw_arg.clone(),
} }
}) })
.collect::<Vec<RpcArg>>(); .collect::<Vec<IxArg>>();
// Remove the Anchor accounts argument // Remove the Anchor accounts argument
let anchor = args.remove(0); let anchor = args.remove(0);
let anchor_ident = extract_ident(&anchor.raw_arg).clone(); let anchor_ident = extract_ident(&anchor.raw_arg).clone();
Some(StateRpc { Some(StateIx {
raw_method: m.clone(), raw_method: m.clone(),
ident: m.sig.ident.clone(), ident: m.sig.ident.clone(),
args, args,
@ -215,15 +215,15 @@ pub fn parse(program_mod: syn::ItemMod) -> Program {
} }
}) })
}; };
// Parse all non-state instruction handlers. // Parse all non-state ix handlers.
let rpcs: Vec<Rpc> = mod_content let ixs: Vec<Ix> = mod_content
.iter() .iter()
.filter_map(|item| match item { .filter_map(|item| match item {
syn::Item::Fn(item_fn) => Some(item_fn), syn::Item::Fn(item_fn) => Some(item_fn),
_ => None, _ => None,
}) })
.map(|method: &syn::ItemFn| { .map(|method: &syn::ItemFn| {
let mut args: Vec<RpcArg> = method let mut args: Vec<IxArg> = method
.sig .sig
.inputs .inputs
.iter() .iter()
@ -233,7 +233,7 @@ pub fn parse(program_mod: syn::ItemMod) -> Program {
syn::Pat::Ident(ident) => &ident.ident, syn::Pat::Ident(ident) => &ident.ident,
_ => panic!("invalid syntax"), _ => panic!("invalid syntax"),
}; };
RpcArg { IxArg {
name: ident.clone(), name: ident.clone(),
raw_arg: arg.clone(), raw_arg: arg.clone(),
} }
@ -245,7 +245,7 @@ pub fn parse(program_mod: syn::ItemMod) -> Program {
let anchor = args.remove(0); let anchor = args.remove(0);
let anchor_ident = extract_ident(&anchor.raw_arg).clone(); let anchor_ident = extract_ident(&anchor.raw_arg).clone();
Rpc { Ix {
raw_method: method.clone(), raw_method: method.clone(),
ident: method.sig.ident.clone(), ident: method.sig.ident.clone(),
args, args,
@ -256,7 +256,7 @@ pub fn parse(program_mod: syn::ItemMod) -> Program {
Program { Program {
state, state,
rpcs, ixs,
name: mod_ident.clone(), name: mod_ident.clone(),
program_mod, program_mod,
} }