Struct darling::util::SpannedValue

pub struct SpannedValue<T> { /* private fields */ }

A value and an associated position in source code. The main use case for this is to preserve position information to emit warnings from proc macros. You can use a SpannedValue<T> as a field in any struct that implements or derives any of darling’s core traits.

To access the underlying value, use the struct’s Deref implementation.

Defaulting

This type is meant to be used in conjunction with attribute-extracted options, but the user may not always explicitly set those options in their source code. In this case, using Default::default() will create an instance which points to Span::call_site().

Implementations

impl<T> SpannedValue<T>

pub fn new(value: T, span: Span) -> SpannedValue<T>

pub fn span(&self) -> Span

Get the source code location referenced by this struct.

Trait Implementations

impl<T> AsRef<T> for SpannedValue<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Clone for SpannedValue<T> where
    T: Clone, 

fn clone(&self) -> SpannedValue<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for SpannedValue<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Default for SpannedValue<T> where
    T: Default, 

fn default() -> SpannedValue<T>

Returns the “default value” for a type.

impl<T> Deref for SpannedValue<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for SpannedValue<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T> From<T> for SpannedValue<T> where
    T: Spanned, 

fn from(value: T) -> SpannedValue<T>

Converts to this type from the input type.

impl<T> FromDeriveInput for SpannedValue<T> where
    T: FromDeriveInput, 

fn from_derive_input(value: &DeriveInput) -> Result<SpannedValue<T>, Error>

Create an instance from syn::DeriveInput, or return an error.

impl<T> FromField for SpannedValue<T> where
    T: FromField, 

fn from_field(value: &Field) -> Result<SpannedValue<T>, Error>

impl<T> FromGenericParam for SpannedValue<T> where
    T: FromGenericParam, 

fn from_generic_param(value: &GenericParam) -> Result<SpannedValue<T>, Error>

impl<T> FromGenerics for SpannedValue<T> where
    T: FromGenerics, 

fn from_generics(value: &Generics) -> Result<SpannedValue<T>, Error>

impl<T> FromMeta for SpannedValue<T> where
    T: FromMeta, 

fn from_meta(value: &Meta) -> Result<SpannedValue<T>, Error>

Create an instance from a syn::Meta by dispatching to the format-appropriate trait function. This generally should not be overridden by implementers.

fn from_nested_meta(item: &NestedMeta) -> Result<Self, Error>

fn from_word() -> Result<Self, Error>

Create an instance from the presence of the word in the attribute with no additional options specified.

fn from_list(items: &[NestedMeta]) -> Result<Self, Error>

Create an instance from a list of nested meta items.

fn from_value(value: &Lit) -> Result<Self, Error>

Create an instance from a literal value of either foo = "bar" or foo("bar"). This dispatches to the appropriate method based on the type of literal encountered, and generally should not be overridden by implementers.

fn from_char(value: char) -> Result<Self, Error>

Create an instance from a char literal in a value position.

fn from_string(value: &str) -> Result<Self, Error>

Create an instance from a string literal in a value position.

fn from_bool(value: bool) -> Result<Self, Error>

Create an instance from a bool literal in a value position.

impl<T> FromTypeParam for SpannedValue<T> where
    T: FromTypeParam, 

fn from_type_param(value: &TypeParam) -> Result<SpannedValue<T>, Error>

impl<T> FromVariant for SpannedValue<T> where
    T: FromVariant, 

fn from_variant(value: &Variant) -> Result<SpannedValue<T>, Error>

Create an instance from syn::Variant, or return an error.