Error redesign

lang/attribute/account/src/lib.rs

@@ -146,18 +146,18 @@ pub fn account(
                 // It's expected on-chain programs deserialize via zero-copy.
                 #[automatically_derived]
                 impl #impl_gen anchor_lang::AccountDeserialize for #account_name #type_gen #where_clause {
-                    fn try_deserialize(buf: &mut &[u8]) -> std::result::Result<Self, ProgramError> {
+                    fn try_deserialize(buf: &mut &[u8]) -> anchor_lang::AnchorResult<Self> {
                         if buf.len() < #discriminator.len() {
-                            return Err(anchor_lang::error::ErrorCode::AccountDiscriminatorNotFound.into());
+                            return anchor_lang::anchor_attribute_error::error!(anchor_lang::error::ErrorCode::AccountDiscriminatorNotFound);
                         }
                         let given_disc = &buf[..8];
                         if &#discriminator != given_disc {
-                            return Err(anchor_lang::error::ErrorCode::AccountDiscriminatorMismatch.into());
+                            return anchor_lang::anchor_attribute_error::error!(anchor_lang::error::ErrorCode::AccountDiscriminatorMismatch);
                         }
                         Self::try_deserialize_unchecked(buf)
                     }
 
-                    fn try_deserialize_unchecked(buf: &mut &[u8]) -> std::result::Result<Self, ProgramError> {
+                    fn try_deserialize_unchecked(buf: &mut &[u8]) -> anchor_lang::AnchorResult<Self> {
                         let data: &[u8] = &buf[8..];
                         // Re-interpret raw bytes into the POD data structure.
                         let account = anchor_lang::__private::bytemuck::from_bytes(data);
@@ -175,34 +175,35 @@ pub fn account(
 
                 #[automatically_derived]
                 impl #impl_gen anchor_lang::AccountSerialize for #account_name #type_gen #where_clause {
-                    fn try_serialize<W: std::io::Write>(&self, writer: &mut W) -> std::result::Result<(), ProgramError> {
-                        writer.write_all(&#discriminator).map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotSerialize)?;
-                        AnchorSerialize::serialize(
-                            self,
-                            writer
-                        )
-                            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotSerialize)?;
+                    fn try_serialize<W: std::io::Write>(&self, writer: &mut W) -> AnchorResult<()> {
+                        if writer.write_all(&#discriminator).is_err() {
+                            return anchor_lang::anchor_attribute_error::error!(anchor_lang::error::ErrorCode::AccountDidNotSerialize);
+                        }
+
+                        if AnchorSerialize::serialize(self, writer).is_err() {
+                            return anchor_lang::anchor_attribute_error::error!(anchor_lang::error::ErrorCode::AccountDidNotSerialize);
+                        }
                         Ok(())
                     }
                 }
 
                 #[automatically_derived]
                 impl #impl_gen anchor_lang::AccountDeserialize for #account_name #type_gen #where_clause {
-                    fn try_deserialize(buf: &mut &[u8]) -> std::result::Result<Self, ProgramError> {
+                    fn try_deserialize(buf: &mut &[u8]) -> anchor_lang::AnchorResult<Self> {
                         if buf.len() < #discriminator.len() {
-                            return Err(anchor_lang::error::ErrorCode::AccountDiscriminatorNotFound.into());
+                            return anchor_lang::anchor_attribute_error::error!(anchor_lang::error::ErrorCode::AccountDiscriminatorNotFound);
                         }
                         let given_disc = &buf[..8];
                         if &#discriminator != given_disc {
-                            return Err(anchor_lang::error::ErrorCode::AccountDiscriminatorMismatch.into());
+                            return anchor_lang::anchor_attribute_error::error!(anchor_lang::error::ErrorCode::AccountDiscriminatorMismatch);
                         }
                         Self::try_deserialize_unchecked(buf)
                     }
 
-                    fn try_deserialize_unchecked(buf: &mut &[u8]) -> std::result::Result<Self, ProgramError> {
+                    fn try_deserialize_unchecked(buf: &mut &[u8]) -> anchor_lang::AnchorResult<Self> {
                         let mut data: &[u8] = &buf[8..];
-                        AnchorDeserialize::deserialize(&mut data)
-                            .map_err(|_| anchor_lang::error::ErrorCode::AccountDidNotDeserialize.into())
+                        let temp = AnchorDeserialize::deserialize(&mut data);
+                        temp.or_else(|_| anchor_lang::anchor_attribute_error::error!(anchor_lang::error::ErrorCode::AccountDidNotDeserialize))
                     }
                 }
 

lang/attribute/error/src/lib.rs

@@ -1,9 +1,15 @@
 extern crate proc_macro;
 
+use proc_macro::TokenStream;
+use quote::quote;
+
 use anchor_syn::codegen::error as error_codegen;
 use anchor_syn::parser::error as error_parser;
 use anchor_syn::ErrorArgs;
-use syn::parse_macro_input;
+use syn::{
+    parse::{Parse, Result as ParseResult},
+    parse_macro_input, Expr, Token,
+};
 
 /// Generates `Error` and `type Result<T> = Result<T, Error>` types to be
 /// used as return types from Anchor instruction handlers. Importantly, the
@@ -47,7 +53,7 @@ use syn::parse_macro_input;
 /// The `#[msg(..)]` attribute is inert, and is used only as a marker so that
 /// parsers  and IDLs can map error codes to error messages.
 #[proc_macro_attribute]
-pub fn error(
+pub fn error_codes(
     args: proc_macro::TokenStream,
     input: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {
@@ -59,3 +65,54 @@ pub fn error(
     let error = error_codegen::generate(error_parser::parse(&mut error_enum, args));
     proc_macro::TokenStream::from(error)
 }
+
+#[proc_macro]
+pub fn error(ts: proc_macro::TokenStream) -> TokenStream {
+    let file = file!();
+    let line = line!();
+    let input = parse_macro_input!(ts as ErrorInput);
+    let error_code = input.error_code;
+    let error_msg_inputs = input.error_msg_inputs;
+    let error_msg_inputs = if error_msg_inputs.is_empty() {
+        quote! {
+            #error_code.to_string()
+        }
+    } else {
+        quote! {
+            format!(#error_code.to_string(), #(#error_msg_inputs),*)
+        }
+    };
+    quote! {
+            Err(anchor_lang::error::Error::from(
+                anchor_lang::error::AnchorError {
+                program_id: None,
+                error_code_string: format!("{:?}", #error_code), // TODO: dont use format here
+                error_code_number: #error_code.into(),
+                error_msg: #error_msg_inputs,
+                source: anchor_lang::error::Source {
+                    filename: #file,
+                    line: #line
+                }
+            }))
+    }
+    .into()
+}
+
+struct ErrorInput {
+    error_code: Expr,
+    error_msg_inputs: Vec<Expr>,
+}
+
+impl Parse for ErrorInput {
+    fn parse(stream: syn::parse::ParseStream) -> ParseResult<Self> {
+        let error_code = stream.call(Expr::parse)?;
+        let mut error_msg_inputs = vec![];
+        while stream.parse::<Token![,]>().is_ok() {
+            error_msg_inputs.push(stream.call(Expr::parse)?);
+        }
+        Ok(Self {
+            error_code,
+            error_msg_inputs,
+        })
+    }
+}

lang/attribute/interface/src/lib.rs

@@ -26,7 +26,7 @@ use syn::parse_macro_input;
 ///
 /// #[interface]
 /// pub trait Auth<'info, T: Accounts<'info>> {
-///     fn is_authorized(ctx: Context<T>, current: u64, new: u64) -> ProgramResult;
+///     fn is_authorized(ctx: Context<T>, current: u64, new: u64) -> AnchorResult<()>;
 /// }
 ///
 /// #[program]
@@ -104,7 +104,7 @@ use syn::parse_macro_input;
 ///     pub struct CounterAuth;
 ///
 ///     impl<'info> Auth<'info, Empty> for CounterAuth {
-///         fn is_authorized(_ctx: Context<Empty>, current: u64, new: u64) -> ProgramResult {
+///         fn is_authorized(_ctx: Context<Empty>, current: u64, new: u64) -> AnchorResult<()> {
 ///             if current % 2 == 0 {
 ///                 if new % 2 == 0 {
 ///                     return Err(ProgramError::Custom(50)); // Arbitrary error code.
@@ -200,7 +200,7 @@ pub fn interface(
                 pub fn #method_name<'a,'b, 'c, 'info, T: anchor_lang::Accounts<'info> + anchor_lang::ToAccountMetas + anchor_lang::ToAccountInfos<'info>>(
                     ctx: anchor_lang::context::CpiContext<'a, 'b, 'c, 'info, T>,
                     #(#args),*
-                ) -> anchor_lang::solana_program::entrypoint::ProgramResult {
+                ) -> anchor_lang::AnchorResult {
                     #args_struct
 
                     let ix = {

lang/derive/accounts/src/lib.rs

@@ -22,7 +22,7 @@ use syn::parse_macro_input;
 ///
 /// ```ignore
 /// ...
-/// pub fn initialize(ctx: Context<Create>, bump: u8, authority: Pubkey, data: u64) -> ProgramResult {
+/// pub fn initialize(ctx: Context<Create>, bump: u8, authority: Pubkey, data: u64) -> AnchorResult<()> {
 ///     ...
 ///     Ok(())
 /// }

lang/src/accounts/account.rs

@@ -5,7 +5,6 @@ use crate::*;
 use solana_program::account_info::AccountInfo;
 use solana_program::entrypoint::ProgramResult;
 use solana_program::instruction::AccountMeta;
-use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
 use std::collections::BTreeMap;
 use std::fmt;
@@ -44,7 +43,7 @@ use std::ops::{Deref, DerefMut};
 /// #[program]
 /// mod hello_anchor {
 ///     use super::*;
-///     pub fn set_data(ctx: Context<SetData>, data: u64) -> ProgramResult {
+///     pub fn set_data(ctx: Context<SetData>, data: u64) -> AnchorResult<()> {
 ///         if (*ctx.accounts.auth_account).authorized {
 ///             (*ctx.accounts.my_account).data = data;
 ///         }
@@ -161,7 +160,7 @@ use std::ops::{Deref, DerefMut};
 ///     pub fn set_initial_admin(
 ///         ctx: Context<SetInitialAdmin>,
 ///         admin_key: Pubkey
-///     ) -> ProgramResult {
+///     ) -> AnchorResult<()> {
 ///         ctx.accounts.admin_settings.admin_key = admin_key;
 ///         Ok(())
 ///     }
@@ -243,12 +242,12 @@ impl<'a, T: AccountSerialize + AccountDeserialize + Owner + Clone> Account<'a, T
 
     /// Deserializes the given `info` into a `Account`.
     #[inline(never)]
-    pub fn try_from(info: &AccountInfo<'a>) -> Result<Account<'a, T>, ProgramError> {
+    pub fn try_from(info: &AccountInfo<'a>) -> AnchorResult<Account<'a, T>> {
         if info.owner == &system_program::ID && info.lamports() == 0 {
-            return Err(ErrorCode::AccountNotInitialized.into());
+            return anchor_attribute_error::error!(ErrorCode::AccountNotInitialized);
         }
         if info.owner != &T::owner() {
-            return Err(ErrorCode::AccountOwnedByWrongProgram.into());
+            return anchor_attribute_error::error!(ErrorCode::AccountOwnedByWrongProgram);
         }
         let mut data: &[u8] = &info.try_borrow_data()?;
         Ok(Account::new(info.clone(), T::try_deserialize(&mut data)?))
@@ -258,12 +257,12 @@ impl<'a, T: AccountSerialize + AccountDeserialize + Owner + Clone> Account<'a, T
     /// the account discriminator. Be careful when using this and avoid it if
     /// possible.
     #[inline(never)]
-    pub fn try_from_unchecked(info: &AccountInfo<'a>) -> Result<Account<'a, T>, ProgramError> {
+    pub fn try_from_unchecked(info: &AccountInfo<'a>) -> AnchorResult<Account<'a, T>> {
         if info.owner == &system_program::ID && info.lamports() == 0 {
-            return Err(ErrorCode::AccountNotInitialized.into());
+            return anchor_attribute_error::error!(ErrorCode::AccountNotInitialized);
         }
         if info.owner != &T::owner() {
-            return Err(ErrorCode::AccountOwnedByWrongProgram.into());
+            return anchor_attribute_error::error!(ErrorCode::AccountOwnedByWrongProgram);
         }
         let mut data: &[u8] = &info.try_borrow_data()?;
         Ok(Account::new(
@@ -274,7 +273,7 @@ impl<'a, T: AccountSerialize + AccountDeserialize + Owner + Clone> Account<'a, T
 
     /// Reloads the account from storage. This is useful, for example, when
     /// observing side effects after CPI.
-    pub fn reload(&mut self) -> ProgramResult {
+    pub fn reload(&mut self) -> AnchorResult<()> {
         let mut data: &[u8] = &self.info.try_borrow_data()?;
         self.account = T::try_deserialize(&mut data)?;
         Ok(())
@@ -288,15 +287,15 @@ impl<'a, T: AccountSerialize + AccountDeserialize + Owner + Clone> Account<'a, T
     ///
     /// Instead of this:
     /// ```ignore
-    /// pub fn new_user(ctx: Context<CreateUser>, new_user:User) -> ProgramResult {
+    /// pub fn new_user(ctx: Context<CreateUser>, new_user:User) -> AnchorResult<()> {
     ///     (*ctx.accounts.user_to_create).name = new_user.name;
     ///     (*ctx.accounts.user_to_create).age = new_user.age;
     ///     (*ctx.accounts.user_to_create).address = new_user.address;
     /// }
     /// ```
     /// You can do this:
     /// ```ignore
-    /// pub fn new_user(ctx: Context<CreateUser>, new_user:User) -> ProgramResult {
+    /// pub fn new_user(ctx: Context<CreateUser>, new_user:User) -> AnchorResult<()> {
     ///     ctx.accounts.user_to_create.set_inner(new_user);
     /// }
     /// ```
@@ -316,9 +315,9 @@ where
         accounts: &mut &[AccountInfo<'info>],
         _ix_data: &[u8],
         _bumps: &mut BTreeMap<String, u8>,
-    ) -> Result<Self, ProgramError> {
+    ) -> AnchorResult<Self> {
         if accounts.is_empty() {
-            return Err(ErrorCode::AccountNotEnoughKeys.into());
+            return anchor_attribute_error::error!(ErrorCode::AccountNotEnoughKeys);
         }
         let account = &accounts[0];
         *accounts = &accounts[1..];
@@ -329,7 +328,7 @@ where
 impl<'info, T: AccountSerialize + AccountDeserialize + Owner + Clone> AccountsExit<'info>
     for Account<'info, T>
 {
-    fn exit(&self, program_id: &Pubkey) -> ProgramResult {
+    fn exit(&self, program_id: &Pubkey) -> AnchorResult<()> {
         // Only persist if the owner is the current program.
         if &T::owner() == program_id {
             let info = self.to_account_info();
@@ -345,7 +344,7 @@ impl<'info, T: AccountSerialize + AccountDeserialize + Owner + Clone> AccountsEx
 impl<'info, T: AccountSerialize + AccountDeserialize + Owner + Clone> AccountsClose<'info>
     for Account<'info, T>
 {
-    fn close(&self, sol_destination: AccountInfo<'info>) -> ProgramResult {
+    fn close(&self, sol_destination: AccountInfo<'info>) -> AnchorResult<()> {
         crate::common::close(self.to_account_info(), sol_destination)
     }
 }

lang/src/accounts/account_info.rs

@@ -3,10 +3,9 @@
 //! should be used instead.
 
 use crate::error::ErrorCode;
-use crate::{Accounts, AccountsExit, ToAccountInfos, ToAccountMetas};
+use crate::{Accounts, AccountsExit, AnchorResult, ToAccountInfos, ToAccountMetas};
 use solana_program::account_info::AccountInfo;
 use solana_program::instruction::AccountMeta;
-use solana_program::program_error::ProgramError;
 use solana_program::pubkey::Pubkey;
 use std::collections::BTreeMap;
 
@@ -16,9 +15,9 @@ impl<'info> Accounts<'info> for AccountInfo<'info> {
         accounts: &mut &[AccountInfo<'info>],
         _ix_data: &[u8],
         _bumps: &mut BTreeMap<String, u8>,
-    ) -> Result<Self, ProgramError> {
+    ) -> AnchorResult<Self> {
         if accounts.is_empty() {
-            return Err(ErrorCode::AccountNotEnoughKeys.into());
+            return anchor_attribute_error::error!(ErrorCode::AccountNotEnoughKeys);
         }
         let account = &accounts[0];
         *accounts = &accounts[1..];