Enum TracersError

pub enum TracersError {
    InvalidProvider {
        message: String,
        syn_error: Error,
    },
    SynError {
        message: String,
        syn_error: Error,
    },
    DarlingError {
        message: String,
        darling_error: Arc<Mutex<Error>>,
    },
    InvalidCallExpression {
        message: String,
        syn_error: Error,
    },
    OtherError {
        message: String,
        error: Error,
    },
    MissingCallInBuildRs,
    BuildInfoReadError {
        message: String,
        build_info_path: String,
        error: Error,
    },
    BuildInfoWriteError {
        message: String,
        build_info_path: String,
        error: Error,
    },
    ProviderTraitNotProcessedError {
        message: String,
        trait_name: String,
        error: Error,
    },
    CodeGenerationError {
        message: String,
    },
    NativeCodeGenerationError {
        message: String,
        error: Error,
    },
}

Variants

InvalidProvider

Fields

message: String

syn_error: Error

SynError

Fields

message: String

syn_error: Error

DarlingError

Fields

message: String

darling_error: Arc<Mutex<Error>>

InvalidCallExpression

Fields

message: String

syn_error: Error

OtherError

Fields

message: String

error: Error

MissingCallInBuildRs

BuildInfoReadError

Fields

message: String

build_info_path: String

error: Error

BuildInfoWriteError

Fields

message: String

build_info_path: String

error: Error

ProviderTraitNotProcessedError

Fields

message: String

trait_name: String

error: Error

CodeGenerationError

Fields

message: String

NativeCodeGenerationError

Fields

message: String

error: Error

Implementations

impl TracersError

pub fn invalid_provider<T: ToTokens>( message: impl AsRef<str>, element: T, ) -> TracersError

pub fn syn_error(message: impl AsRef<str>, e: Error) -> TracersError

pub fn syn_like_error<T: ToTokens, U: Display>( message: U, tokens: T, ) -> TracersError

When we need to raise an error that is attached to a syn type (meaning the span of the error will correctly be associated with that type), this method is used. There is no actual syn error, we’re just reporting a logic error of our own while processing some syn types.

pub fn darling_error(e: DarlingError) -> TracersError

pub fn invalid_call_expression<T: ToTokens>( message: impl AsRef<str>, element: T, ) -> TracersError

pub fn other_error<D: Display + Send + Sync + 'static>( e: Context<D>, ) -> TracersError

pub fn missing_call_in_build_rs() -> TracersError

pub fn build_info_read_error(build_info_path: PathBuf, e: Error) -> TracersError

pub fn build_info_write_error( build_info_path: PathBuf, e: Error, ) -> TracersError

pub fn provider_trait_not_processed_error<T: AsRef<str>, E: Into<Error> + Display>( trait_name: T, e: E, ) -> TracersError

pub fn code_generation_error<S: AsRef<str>>(message: S) -> TracersError

pub fn native_code_generation_error<S: AsRef<str>, E: Into<Error> + Display>( message: S, e: E, ) -> TracersError

pub fn into_syn_error(self) -> Error

Converts this error type into a syn::Error, preserving context from spans and elements if any were given

pub fn into_compiler_error(self) -> TokenStream

Convert this error into a TokenStream such that when the compiler consumes the token stream it will evaluate to a compile error, with the span corresponding to whatever element was used to report the error. For those error types that don’t have a corresponding element, the call site of the macro will be used

Trait Implementations

impl Debug for TracersError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for TracersError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Fail for TracersError

fn name(&self) -> Option<&str>

Returns the “name” of the error.

fn cause(&self) -> Option<&dyn Fail>

Returns a reference to the underlying cause of this failure, if it is an error that wraps other errors.

fn backtrace(&self) -> Option<&Backtrace>

Returns a reference to the Backtrace carried by this failure, if it carries one.

fn context<D>(self, context: D) -> Context<D>

where D: Display + Send + Sync + 'static, Self: Sized,

Provides context for this failure.

fn compat(self) -> Compat<Self>

where Self: Sized,

Wraps this failure in a compatibility wrapper that implements std::error::Error.

impl<D: Display + Send + Sync + 'static> From<Context<D>> for TracersError

Implement conversion from regular errors into a TracersError, but only if the error has been given a context message using the .context() extension method provided by failure

fn from(failure: Context<D>) -> TracersError

Converts to this type from the input type.

impl PartialEq for TracersError

fn eq(&self, other: &TracersError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Send for TracersError

impl Sync for TracersError