Enum tracers_codegen::TracersError

pub enum TracersError {
    InvalidProvider {
        message: String,
        syn_error: Error,
    },
    SynError {
        message: String,
        syn_error: Error,
    },
    DarlingError {
        message: String,
        darling_error: Arc<Mutex<DarlingError>>,
    },
    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 of InvalidProvider

message: Stringsyn_error: Error

SynError

Fields of SynError

message: Stringsyn_error: Error

DarlingError

Fields of DarlingError

message: Stringdarling_error: Arc<Mutex<DarlingError>>

InvalidCallExpression

Fields of InvalidCallExpression

message: Stringsyn_error: Error

OtherError

Fields of OtherError

message: Stringerror: Error

MissingCallInBuildRs

BuildInfoReadError

Fields of BuildInfoReadError

message: Stringbuild_info_path: Stringerror: Error

BuildInfoWriteError

Fields of BuildInfoWriteError

message: Stringbuild_info_path: Stringerror: Error

ProviderTraitNotProcessedError

Fields of ProviderTraitNotProcessedError

message: Stringtrait_name: Stringerror: Error

CodeGenerationError

Fields of CodeGenerationError

message: String

NativeCodeGenerationError

Fields of NativeCodeGenerationError

message: Stringerror: Error

Methods

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 Send for TracersError

impl Sync for TracersError

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

Performs the conversion.

impl PartialEq<TracersError> for TracersError

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Display for TracersError

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

Formats the value using the given formatter.

impl Debug 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, 

Provides context for this failure.

fn compat(self) -> Compat<Self>

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