Enum TypeName 

#[non_exhaustive]
pub enum TypeName {
    Primitive(PrimitiveType),
    Named(PathType),
    Reference(Lifetime, Mutability, Box<TypeName>),
    Box(Box<TypeName>),
    Option(Box<TypeName>),
    Result(Box<TypeName>, Box<TypeName>, bool),
    Writeable,
    StrReference(Option<Lifetime>, StringEncoding),
    PrimitiveSlice(Option<(Lifetime, Mutability)>, PrimitiveType),
    StrSlice(StringEncoding),
    Unit,
    SelfType(PathType),
    Ordering,
}

A local type reference, such as the type of a field, parameter, or return value. Unlike CustomType, which represents a type declaration, TypeNames can compose types through references and boxing, and can also capture unresolved paths.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Primitive(PrimitiveType)

A built-in Rust scalar primitive.

Named(PathType)

An unresolved path to a custom type, which can be resolved after all types are collected with [TypeName::resolve()].

Reference(Lifetime, Mutability, Box<TypeName>)

An optionally mutable reference to another type.

Box(Box<TypeName>)

A Box<T> type.

Option(Box<TypeName>)

A Option<T> type.

Result(Box<TypeName>, Box<TypeName>, bool)

A Result<T, E> or diplomat_runtime::DiplomatWriteable type. If the bool is true, it’s Result

Writeable

StrReference(Option<Lifetime>, StringEncoding)

A &DiplomatStr or Box<DiplomatStr> type. Owned strings don’t have a lifetime.

PrimitiveSlice(Option<(Lifetime, Mutability)>, PrimitiveType)

A &[T] or Box<[T]> type, where T is a primitive. Owned slices don’t have a lifetime or mutability.

StrSlice(StringEncoding)

&[&DiplomatStr]

Unit

The () type.

SelfType(PathType)

The Self type.

Ordering

std::cmp::Ordering or core::cmp::Ordering

The path must be present! Ordering will be parsed as an AST type!

Implementations

impl TypeName

pub fn to_syn(&self) -> Type

Converts the TypeName back into an AST node that can be spliced into a program.

pub fn from_syn(ty: &Type, self_path_type: Option<PathType>) -> TypeName

Extract a TypeName from a syn::Type AST node. The following rules are used to infer TypeName variants:

• If the type is a path with a single element that is the name of a Rust primitive, returns a TypeName::Primitive
• If the type is a path with a single element Box, returns a TypeName::Box with the type parameter recursively converted
• If the type is a path with a single element Option, returns a TypeName::Option with the type parameter recursively converted
• If the type is a path with a single element Self and self_path_type is provided, returns a TypeName::Named
• If the type is a path with a single element Result, returns a TypeName::Result with the type parameters recursively converted
• If the type is a path equal to [diplomat_runtime::DiplomatResult], returns a [TypeName::DiplomatResult] with the type parameters recursively converted
• If the type is a path equal to [diplomat_runtime::DiplomatWriteable], returns a TypeName::Writeable
• If the type is a owned or borrowed string type, returns a TypeName::StrReference
• If the type is a owned or borrowed slice of a Rust primitive, returns a TypeName::PrimitiveSlice
• If the type is a reference (& or &mut), returns a TypeName::Reference with the referenced type recursively converted
• Otherwise, assume that the reference is to a CustomType in either the current module or another one, returns a TypeName::Named

pub fn is_self(&self) -> bool

Returns true if self is the TypeName::SelfType variant, otherwise false.

pub fn visit_lifetimes<'a, F, B>(&'a self, visit: &mut F) -> ControlFlow<B>

where F: FnMut(&'a Lifetime, LifetimeOrigin) -> ControlFlow<B>,

Recurse down the type tree, visiting all lifetimes.

Using this function, you can collect all the lifetimes into a collection, or examine each one without having to make any additional allocations.

pub fn any_lifetime<'a, F>(&'a self, f: F) -> bool

where F: FnMut(&'a Lifetime, LifetimeOrigin) -> bool,

Returns true if any lifetime satisfies a predicate, otherwise false.

This method is short-circuiting, meaning that if the predicate ever succeeds, it will return immediately.

pub fn all_lifetimes<'a, F>(&'a self, f: F) -> bool

where F: FnMut(&'a Lifetime, LifetimeOrigin) -> bool,

Returns true if all lifetimes satisfy a predicate, otherwise false.

This method is short-circuiting, meaning that if the predicate ever fails, it will return immediately.

pub fn longer_lifetimes<'env>( &self, lifetime_env: &'env LifetimeEnv, ) -> Vec<&'env NamedLifetime>

Returns all lifetimes in a LifetimeEnv that must live at least as long as the type.

pub fn shorter_lifetimes<'env>( &self, lifetime_env: &'env LifetimeEnv, ) -> Vec<&'env NamedLifetime>

Returns all lifetimes in a LifetimeEnv that are outlived by the type.

fn transitive_lifetime_bounds<'env>( &self, transitivity: LifetimeTransitivity<'env>, ) -> Vec<&'env NamedLifetime>

Visits the provided LifetimeTransitivity value with all NamedLifetimes in the type tree, and returns the transitively reachable lifetimes.

pub fn is_zst(&self) -> bool

pub fn is_pointer(&self) -> bool

Trait Implementations

impl Clone for TypeName

fn clone(&self) -> TypeName

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeName

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypeName

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TypeName

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

Formats the value using the given formatter.

impl Hash for TypeName

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TypeName

fn eq(&self, other: &TypeName) -> 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 Serialize for TypeName

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TypeName

impl StructuralPartialEq for TypeName