Patterns for Defensive Programming in Rust

私は趣味として、コード中に

// this should never happen in code

コードスメル：ベクタへの直接インデックスアクセス

if !matching_users.is_empty() {
    let existing_user = &matching_users[0];
}

リファクタリング時に

is_empty()

matching_users[0]

スライスパターンマッチングで修正

match matching_users.as_slice() {
    [] => todo!("ユーザーが見つからない場合どうする？"),
    [existing_user] => { /* 安全！ 要素はちょうど 1 個 */ }
    _ => Err(RepositoryError::DuplicateUsers),
}

コンパイラにすべての状態を考慮させることで、隠れたエッジケースが明らかになります。

コードスメル：

Default

の遅延使用

..Default::default()

let foo = Foo {
    field1: value1,
    field2: value2,
    ..Default::default()
};

すべてのフィールドを明示的に設定

let foo = Foo {
    field1: value1,
    field2: value2,
    field3: value3,
    field4: value4,
};

まだデフォルト値が欲しい場合は：

let Foo { field1, field2, field3, field4 } = Foo::default();

let foo = Foo {
    field1: value1,
    field2: value2,
    field3,
    field4,
};

新しいフィールドが追加されるとコンパイラが警告します。

コードスメル：脆弱なトレイト実装

構造体を分解（デストラクチャリング）すると、忘れたフィールドに気づきやすくなります。

impl PartialEq for PizzaOrder {
    fn eq(&self, other: &Self) -> bool {
        let Self { size, toppings, crust_type, ordered_at: _ } = self;
        let Self { size: o_size, toppings: o_toppings, crust_type: o_crust, ordered_at: _ } = other;

        size == o_size && toppings == o_toppings && crust_type == o_crust
    }
}

extra_cheese

コードスメル：

From

と

TryFrom

の使い分け

変換が失敗する可能性があるなら

TryFrom

impl TryFrom<&DetectorStartupErrorReport> for DetectorStartupErrorSubject {
    fn try_from(report: &DetectorStartupErrorReport) -> Result<Self, Error> {
        let postfix = report.get_identifier()
            .or_else(get_binary_name)
            .ok_or(Error::MissingIdentifier)?;

        Ok(Self(StreamSubject::from(
            format!("apps.errors.detectors.startup.{postfix}").as_str(),
        )))
    }
}

From

コードスメル：非網羅的マッチ

ワイルドカード

_

match self {
    Self::Variant1 => { /* ... */ }
    Self::Variant2 => { /* ... */ }
    Self::Variant3 | Self::Variant4 => { /* 共通ロジック */ }
}

新しいバリアントが追加されたときにコンパイラが警告します。

コードスメル：未使用変数の

_

プレースホルダー

説明的な名前を付けるだけで意図が明確になります。

match self {
    Self::Rocket { has_fuel: _, has_crew: _, .. } => { /* ... */ }
}

パターン：一時的なミュータビリティ

ミューテーションを明示し、スコープで限定します。

let data = {
    let mut tmp = get_vec();
    tmp.sort();
    tmp  // 戻り値は不変
};

初期化後に偶発的な変更が起きません。

パターン：コンストラクタの防御的取り扱い

外部コード

#[non_exhaustive]
pub struct S { /* フィールド */ }

impl S {
    pub fn new(field1: String, field2: u32) -> Result<Self, Error> { /* 検証 */ }
}

_private

Seal

内部コード

mod inner {
    struct Seal;
    pub struct S { field1: String, field2: u32, _seal: Seal }

    impl S {
        pub fn new(field1: String, field2: u32) -> Result<Self, Error> { /* 検証 */ }
    }
}
pub use inner::S;

new

パターン：重要な型に

#[must_use]

を付与

#[must_use = "設定が適用されるには構成を使用する必要があります"]
pub struct Config { /* フィールド */ }

impl Config {
    pub fn new() -> Self { /* ... */ }
    pub fn with_timeout(mut self, timeout: Duration) -> Self { self.timeout = timeout; self }
}

結果を無視するとコンパイラが警告します。

コードスメル：ブールパラメータ

ブール値は列挙型やパラメータ構造体に置き換えます。

enum Compression { Strong, Medium, None }
enum Encryption   { AES, ChaCha20, None }
enum Validation   { Enabled, Disabled }

fn process_data(
    data: &[u8],
    compression: Compression,
    encryption: Encryption,
    validation: Validation,
) {
    /* ... */
}

または：

struct ProcessDataParams {
    compression: Compression,
    encryption: Encryption,
    validation: Validation,
}

impl ProcessDataParams {
    pub fn production() -> Self { /* デフォルト */ }
    pub fn development() -> Self { /* デフォルト */ }
}

防御的プログラミングのための Clippy ライン

clippy::indexing_slicing

clippy::fallible_impl_from

From

clippy::wildcard_enum_match_arm

_

clippy::unneeded_field_pattern

..

clippy::fn_params_excessive_bools

clippy::must_use_candidate

#[must_use]

クレートで有効化するには：

#![deny(clippy::indexing_slicing)]
#![deny(clippy::fallible_impl_from)]
#![deny(clippy::wildcard_enum_match_arm)]
#![deny(clippy::unneeded_field_pattern)]
#![deny(clippy::fn_params_excessive_bools)]
#![deny(clippy::must_use_candidate)]

または

Cargo.toml

[lints.clippy]
indexing_slicing = "deny"
fallible_impl_from = "deny"
wildcard_enum_match_arm = "deny"
unneeded_field_pattern = "deny"
fn_params_excessive_bools = "deny"
must_use_candidate = "deny"

結論

Rust における防御的プログラミングは、暗黙の不変条件を明示化しコンパイラで検証することにあります。パターンマッチング、明示的なデフォルト値、分解、制御された生成、

#[must_use]

「// this should never happen」というコメントを書いているときは、一瞬立ち止まり、「コンパイラがその不変条件をどう保証できるか」を考えてみてください。最高のバグとは、コンパイル自体で捕捉されるものです。