Struct TypesMut 

pub struct TypesMut<'db> { /* private fields */ }

A write cursor over the database’s local type library, from Database::types_mut.

Holds the database exclusively. Exposes define for whole declarations and edit for member surgery on an existing named type.

Implementations

impl TypesMut<'_>

pub fn define(&mut self, decl: impl AsRef<str>) -> Result<()>

Parse the C declaration(s) in decl into the database’s local type library.

A struct, union, enum, or typedef declaration becomes a named type that later set_type calls can reference by name, and that named_types then enumerates. Redeclarations are tolerated.

decl may hold several declarations. It is not atomic: on an error, declarations that parsed before the failure are already defined.

db.types_mut().define("struct Point { int x; int y; };")?;
assert!(db.named_types().any(|t| t.name() == "Point"));

Errors

Error::TypeDefineFailed if IDA rejects any declaration (with its own diagnostics), or Error::InteriorNul if decl contains a NUL byte.

Examples found in repository

examples/edits.rs (line 162)

fn defining_types(idb: &mut Database) -> Result<(), Error> {
    println!("\n== types_mut: define ==");

    idb.types_mut()
        .define("struct edit_demo_t { int id; char *name; };")?;
    let present = idb.named_types().any(|t| t.name() == "edit_demo_t");
    println!("  defined edit_demo_t, present in named types: {present}");

    // A declaration referencing the just-defined type resolves against the local til.
    match idb
        .types_mut()
        .define("typedef struct edit_demo_t edit_demo_alias;")
    {
        Ok(()) => println!("  typedef alias to it: ok"),
        Err(e) => println!("  typedef alias: {e}"),
    }

    // A malformed declaration is a typed error carrying IDA's own reason.
    match idb.types_mut().define("struct broken { not valid") {
        Err(Error::TypeDefineFailed { reason, .. }) => {
            println!("  malformed define -> TypeDefineFailed: {reason}");
        }
        other => println!("  malformed define -> unexpected {other:?}"),
    }
    Ok(())
}

/// Member surgery on defined types: append/retype/rename struct fields through the `member(..)`
/// sub-cursor (with the structured rejection when a rename collides), then add and revalue enum
/// constants through `constant(..)`. Each edit auto-saves to the local til; nothing persists past
/// `save = false`.
fn editing_members(idb: &mut Database) -> Result<(), Error> {
    use idakit::types::expr;

    println!("\n== types_mut: edit members ==");

    idb.types_mut()
        .define("struct edit_member_demo { int a; int b; };")?;

    idb.types_mut()
        .edit("edit_member_demo")
        .add_member("c", expr::int32())?;
    idb.types_mut()
        .edit("edit_member_demo")
        .member("a")
        .set_type(expr::char_())?;
    idb.types_mut()
        .edit("edit_member_demo")
        .member("b")
        .rename("beta")?;

    let names: Vec<String> = idb
        .type_named("edit_member_demo")?
        .members()
        .unwrap_or_default()
        .iter()
        .map(|m| m.name.clone())
        .collect();
    println!("  after add + retype + rename, members: {names:?}");

    // Renaming onto an existing name surfaces the structured tinfo_code.
    match idb
        .types_mut()
        .edit("edit_member_demo")
        .member("c")
        .rename("a")
    {
        Err(Error::TypeWrite {
            source: TypeWriteError::Rejected { code, .. },
        }) => println!("  duplicate rename -> Rejected({code})"),
        other => println!("  duplicate rename -> unexpected {other:?}"),
    }

    // Enum constants use the same cursor: add, revalue, rename.
    idb.types_mut()
        .define("enum edit_enum_demo { DEMO_A = 1, DEMO_B = 2 };")?;
    idb.types_mut()
        .edit("edit_enum_demo")
        .add_constant("DEMO_C", 3)?;
    idb.types_mut()
        .edit("edit_enum_demo")
        .constant("DEMO_A")
        .set_value(10)?;
    let constants: Vec<(String, u64)> = match idb.type_named("edit_enum_demo")?.shape() {
        TypeShape::Enum { members, .. } => {
            members.iter().map(|m| (m.name.clone(), m.value)).collect()
        }
        _ => Vec::new(),
    };
    println!("  after add + revalue, constants: {constants:?}");
    Ok(())
}

pub fn delete(&mut self, name: impl AsRef<str>) -> Result<()>

Delete the named type name from the database’s local type library.

The til-level inverse of define: removes a struct, union, enum, or typedef entry outright. Not idempotent: deleting a name that does not exist is TypeWriteError::NoType, the same treatment MemberEdit::delete gives an unresolved member.

db.types_mut().define("struct Scratch { int x; };")?;
db.types_mut().delete("Scratch")?;
assert!(!db.named_types().any(|t| t.name() == "Scratch"));

Errors

TypeWriteError::NoType if no type named name exists, TypeWriteError::Rejected if the kernel refuses the deletion, or Error::InteriorNul if name contains a NUL byte.

pub fn rename( &mut self, name: impl AsRef<str>, new_name: impl AsRef<str>, ) -> Result<()>

Rename the named type name to new_name, in place.

Preserves the type’s ordinal and every reference to it: the underlying SDK call (rename_type) updates the til entry’s name without reallocating it.

db.types_mut().define("struct Old { int x; };")?;
db.types_mut().rename("Old", "New")?;
assert!(db.named_types().any(|t| t.name() == "New"));
assert!(!db.named_types().any(|t| t.name() == "Old"));

Errors

TypeWriteError::NoType if no type named name exists, TypeWriteError::Rejected (e.g. TypeEditCode::DupName if new_name is already taken), or Error::InteriorNul if either name contains a NUL byte.

pub fn forward_declare( &mut self, name: impl AsRef<str>, kind: AggregateKind, ) -> Result<()>

Reserve name in the local type library as an incomplete kind aggregate, with no body.

The explicit counterpart to the "struct Foo;" idiom through define: reserves the tag without describing its members, so a later define with a full body over the same name completes it. Until then, the type reads back as TypeShape::Opaque, the same shape any other unresolved or bodyless named type takes.

use idakit::types::diff::AggregateKind;

db.types_mut()
    .forward_declare("idakit_fwd_probe", AggregateKind::Struct)?;
assert!(db.named_types().any(|t| t.name() == "idakit_fwd_probe"));

Errors

TypeWriteError::Rejected if the kernel refuses the declaration (e.g. name is already taken by an incompatible type), or Error::InteriorNul if name contains a NUL byte.

pub fn edit(&mut self, name: impl Into<String>) -> TypeEdit<'_>

Open the existing named type name for member surgery.

Infallible to acquire: a missing type surfaces as TypeWriteError::NoType from the first edit, so edit(...).member(...).set_type(...) chains without an intermediate check. Each verb is a self-contained load, mutate, and auto-save against the live type.

Examples found in repository

examples/edits.rs (line 198)

fn editing_members(idb: &mut Database) -> Result<(), Error> {
    use idakit::types::expr;

    println!("\n== types_mut: edit members ==");

    idb.types_mut()
        .define("struct edit_member_demo { int a; int b; };")?;

    idb.types_mut()
        .edit("edit_member_demo")
        .add_member("c", expr::int32())?;
    idb.types_mut()
        .edit("edit_member_demo")
        .member("a")
        .set_type(expr::char_())?;
    idb.types_mut()
        .edit("edit_member_demo")
        .member("b")
        .rename("beta")?;

    let names: Vec<String> = idb
        .type_named("edit_member_demo")?
        .members()
        .unwrap_or_default()
        .iter()
        .map(|m| m.name.clone())
        .collect();
    println!("  after add + retype + rename, members: {names:?}");

    // Renaming onto an existing name surfaces the structured tinfo_code.
    match idb
        .types_mut()
        .edit("edit_member_demo")
        .member("c")
        .rename("a")
    {
        Err(Error::TypeWrite {
            source: TypeWriteError::Rejected { code, .. },
        }) => println!("  duplicate rename -> Rejected({code})"),
        other => println!("  duplicate rename -> unexpected {other:?}"),
    }

    // Enum constants use the same cursor: add, revalue, rename.
    idb.types_mut()
        .define("enum edit_enum_demo { DEMO_A = 1, DEMO_B = 2 };")?;
    idb.types_mut()
        .edit("edit_enum_demo")
        .add_constant("DEMO_C", 3)?;
    idb.types_mut()
        .edit("edit_enum_demo")
        .constant("DEMO_A")
        .set_value(10)?;
    let constants: Vec<(String, u64)> = match idb.type_named("edit_enum_demo")?.shape() {
        TypeShape::Enum { members, .. } => {
            members.iter().map(|m| (m.name.clone(), m.value)).collect()
        }
        _ => Vec::new(),
    };
    println!("  after add + revalue, constants: {constants:?}");
    Ok(())
}

Trait Implementations

impl Debug for TypesMut<'_>

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

Formats the value using the given formatter.