clippy::restriction::direct_field_access

[onkoe]

What it does

Prevents direct accesses to fields on a type.

Advantage

• Prevents violation of invariants via direct field access and/or mutation.
• Encapsulates logic within types' getters and setters.
• Limits the amount of debugging and fear while refactoring.
  • It's easy to forget about invariants when doing large refactors, and I've personally made the mistake several times. This lint would make refactors way comfier for me!
  • The lint also prevents new contributors from making severe mistakes.

Drawbacks

• With lots of impl blocks, like in manual trait implementations, you may need to use the #[deny] often.
• Alternatively, one can use a module-level lint attribute, but this can also make modules shorter or less comfy.

Example

pub struct Enemy {
    /// Must be between 0 and 100.
    ///
    /// ## Safety
    ///
    /// Higher numbers could result in undefined behavior by the engine.
    ///
    /// So... make sure to access this field using the getter + setter. I sure
    /// hope you remember!
    health: u8,
}

impl Enemy {
    pub fn health(&self) -> u8 {
        self.health
    }

    pub fn set_health(&mut self, value: u8) -> Result<(), ()> {
        if value <= 100 {
            self.health = value;
            Ok(())
        } else {
            Err(())
        }
    }

    pub fn heal(&mut self) {
        // woops, i forgot to use the setter with its internal checks!
        //
        // i sure hope there's no undefined behavior :(
        self.health += 50
    }
}

Could be written as:

pub struct Enemy { /* ... */ }

#[deny(direct_field_access, reason = "field invariants")]
impl Enemy {
    #[expect(direct_field_access, reason = "getter copies the value")]
    pub fn health(&self) -> u8 { /* ... */ }

    #[expect(direct_field_access, reason = "setter follows invariants")]
    pub fn set_health(&mut self) -> Result<(), ()> { /* ... */ }

    pub fn heal(&mut self) {
        self.set_health(self.health() + 50);
    }
}