Struct Field 

pub struct Field {
    pub name: Option<String>,
    pub index: usize,
    pub ty: String,
    pub resolved_ty: Option<String>,
    pub visibility: Visibility,
    pub docs: Option<String>,
    pub offset: Option<usize>,
    pub size: Option<usize>,
    /* private fields */
}

A field of a struct, enum variant, or union.

Provides field metadata and the ability to navigate to the field’s type definition.

Example

let user = krate.get_struct("User")?;
for field in user.fields()? {
    println!("Field: {}", field.name.as_deref().unwrap_or("<unnamed>"));
    println!("  Type: {}", field.ty);
    println!("  Size: {:?}", field.size);

    // Navigate to the field's type definition
    if let Some(field_type) = field.type_def()? {
        println!("  Defined in: {}", field_type.path());
    }
}

Fields

name: Option<String>

Field name (None for tuple struct fields)

index: usize

Field index in the struct

ty: String

Type as a string

resolved_ty: Option<String>

Resolved type (following aliases)

visibility: Visibility

Field visibility

docs: Option<String>

Doc comments

offset: Option<usize>

Offset in bytes (if layout is known)

size: Option<usize>

Size in bytes (if layout is known)

Implementations

impl Field

pub fn type_def(&self) -> Result<Option<Item>>

Navigate to the type definition for this field’s type.

Returns an Item representing the field’s type definition, if it can be resolved. Returns None for primitive types or external types not in the queried crate.

Example

let user = krate.get_struct("User")?;
for field in user.fields()? {
    if let Some(field_type) = field.type_def()? {
        match field_type {
            Item::Struct(s) => println!("{} is a struct", field.name.unwrap()),
            Item::Enum(e) => println!("{} is an enum", field.name.unwrap()),
            _ => {}
        }
    }
}

Returns

• Ok(Some(Item)) - The type definition was found
• Ok(None) - The type is primitive or external
• Err(_) - An error occurred querying the daemon

Trait Implementations

impl Clone for Field

fn clone(&self) -> Field

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Field

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

Formats the value using the given formatter.