Quelle  options.rs

/// The goal of tracing generic parameter usage.
///
/// Not all uses of type parameters imply a need to add bounds to a generated trait impl.
/// For example, a field of type `<Vec<T> as a::b::Trait>::Associated` does not need a
/// `where T: Serialize` bound in `serde`.
/// However, a proc macro that is attempting to generate a helper struct _would_ need to
/// know about this usage, or else the generated code would reference an unknown type `T`
/// and fail to compile.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum Purpose {
    /// The tracing is being used to generate an `impl` block.
    ///
    /// Uses such as `syn::TypePath.qself` will _not_ be returned.
    BoundImpl,
    /// The tracing is being used to generate a new struct or enum.
    ///
    /// All uses will be returned.
    Declare,
}

/// Control struct for searching type parameters.
///
/// This acts as the search context, preserving information that might have been
/// kept on a visitor in a different implementation.
/// Trait implementers are required to pass this through on any invocations they make.
///
/// # Usage
/// For extensibility, `Options` hides all of its fields from consumers.
/// To create an instance, use the `From<Purpose>` trait implementation:
///
/// ```rust
/// # use darling_core::usage::{Options, Purpose};
/// let opts: Options = Purpose::BoundImpl.into();
/// assert!(!opts.include_type_path_qself());
/// ```
#[derive(Debug, Clone)]
pub struct Options {
    purpose: Purpose,
    #[doc(hidden)]
    __nonexhaustive: (),
}

impl From<Purpose> for Options {
    fn from(purpose: Purpose) -> Self {
        Self {
            purpose,
            __nonexhaustive: (),
        }
    }
}

impl Options {
    /// Returns `true` if the implementer of `UseTypeParams` should search
    /// `<___ as ...>::...` when looking for type parameter uses.
    pub fn include_type_path_qself(&self) -> bool {
        self.purpose == Purpose::Declare
    }
}