Day 061 — マクロ① macro_rules! ⑥ テストが通る str_enum! を「使う側」から壊す：末尾カンマ・doc コメント・重複文字列・定数パス

📚 背景知識（読んでから問題へ）

Day 058 は「マクロの中身の欠陥」をレビューで探しました。今日は視点を変えて、マクロを使う側が書くコードから壊します。macro_rules! の入力は、関数の引数と違って型ではなく字句の並びで受け付けられるので、作者のテストが通っていても、利用者が普通に書く次の入力でコンパイルが通らないことがあります。

• rustfmt が付ける末尾のカンマ
• 型や variant に付ける /// doc コメント（#[doc = "..."] に展開されるので、パターンに書いていなければ弾かれる）
• 同じ値を2か所に書いてしまう入力ミス（型でもパターンでも弾けず、警告だけで通る）

もう一つ、Rust 固有の線引きがあります。$s:expr で受けた式は、"debug" のような文字列リテラルならパターン位置に置けるのに、定数のパス A だと置けません。マクロの入力は「式」なのか「パターンに使えるリテラル」なのか。この線引きが API の約束になります。

扱う題材は、文字列と enum を対応づける定番のマクロです。世界では strum の EnumString・AsRefStr という derive（手続き型マクロ）がこの役を担っています（GitHub Peternator7/strum、2455 star、MIT、最終 push 2026-03-07。GitHub API で 2026-10-03 に取得。crates.io の累計ダウンロード数は 662,264,239）。それを macro_rules! で自作するとき、何が足りなくなるのかを測るのが今日のねらいです。

実務では、設定ファイルのキー、ログレベル、HTTP メソッド、DB のステータス列など、「文字列で保存し enum で扱う」型が1プロジェクトに何十個も出ます。毎回 match を手で書くと、variant を足したのに FromStr の腕を足し忘れる事故が起きるので、マクロか derive にします。

📝 問題

Part 1: コードレビュー（実行する前に答える）

次の PR を受け取りました。テストは3つとも通っています（cargo test で確認済み。edition 2024、rustc 1.96.0）。

📋 コピーmacro_rules! str_enum {
    ($vis:vis enum $name:ident { $($var:ident => $s:expr),* }) => {
        #[derive(Debug, Clone, Copy, PartialEq)]
        $vis enum $name { $($var),* }
        impl $name {
            pub const ALL: &'static [$name] = &[$($name::$var),*];
            pub fn as_str(&self) -> &'static str {
                match self { $($name::$var => $s),* }
            }
        }
        impl std::str::FromStr for $name {
            type Err = String;
            fn from_str(x: &str) -> Result<Self, String> {
                match x { $($s => Ok($name::$var),)* _ => Err(format!("unknown: {x}")) }
            }
        }
    };
}

str_enum! { pub enum Level { Debug => "debug", Info => "info", Warn => "warn" } }

fn main() {
    println!("{:?}", "warn".parse::<Level>());
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn roundtrip() {
        for &v in Level::ALL {
            assert_eq!(v.as_str().parse::<Level>(), Ok(v));
        }
    }
    #[test]
    fn count() { assert_eq!(Level::ALL.len(), 3); }
    #[test]
    fn unknown() { assert!("trace".parse::<Level>().is_err()); }
}

利用者が次の8通りの呼び出しを書きます。実行する前に、それぞれ (a) コンパイルが通るか、(b) 通るなら警告の有無と挙動、(c) 通らないなら何のエラーかを答えてください。

📋 コピー// U1: 末尾カンマ（rustfmt が付ける形）
str_enum! { pub enum L { Debug => "debug", Info => "info", } }

// U2: enum に doc コメント
str_enum! { /// log level
    pub enum L { Debug => "debug", Info => "info" } }

// U3: variant に doc コメント
str_enum! { pub enum L { /// verbose
    Debug => "debug", Info => "info" } }

// U4: 文字列を重複させてしまった
str_enum! { pub enum L { Debug => "x", Info => "x" } }

// U5: 文字列を定数で渡す
const A: &str = "a";
str_enum! { pub enum L { X => A, Y => "b" } }

// U6: 文字列を .trim_end() つきの式で渡す
str_enum! { pub enum L { X => "a".trim_end(), Y => "b" } }

// U7: variant が 0 個
str_enum! { pub enum L { } }

// U8: 別のマクロが $s:expr で受けて転送する
macro_rules! levels {
    ($($v:ident => $s:expr),*) => { str_enum! { pub enum L { $($v => $s),* } } };
}
levels! { Debug => "debug" }

先輩は「$s:expr はパターンに置けないので、元の PR は定数でなくても落ちるし、U8 の転送も壊れるはず」と言っています。 本当にそうか、なぜかを答えてください（レビューでは、自分や他人の思い込みを実機で確かめた方が負けにくいです）。

Part 2: 直す（実装）

U1〜U5・U7 が通るようにマクロを直してください。要件は次のとおりです。

• 末尾カンマを許す。enum と variant に付けた属性（doc コメント・#[derive(...)]）を受け取って、出力する enum にそのまま付ける
• 文字列が重複したらコンパイルエラーにする（警告では足りない。const _: () = ...; と const fn を使う）
• as_str は const fn にする（const NAME: &str = Level::Info.as_str(); が書けること）
• 0 variant の enum でもコンパイルが通る
• 追加したテスト（下の模範解答にある 5 つ）が cargo test で通ること。重複の拒否は手で確認でよい

Part 3: 設計の設問

• D1: 入力を $s:expr ではなく $s:literal にして、定数パス A を受け付けないことにした。何を得て何を失ったか。expr のまま定数も受け付けたければ、出力のどこをどう変える必要があるか。
• D2: 出力する enum に #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] を固定で付けた。利用者が #[derive(Debug)] を自分でも書いたらどうなるか。固定をやめて利用者に全部書かせる案と比べ、採るならどちらか。
• D3: 自作の str_enum! と strum の derive（手続き型マクロ）で、どちらを採るか。判断を変える条件を2つ挙げよ。

💡 ヒント

📋 コピーmacro_rules! str_enum {
    ( $(#[$m:meta])* $vis:vis enum $name:ident {
        $( $(#[$vm:meta])* $var:ident => $s:literal ),* $(,)?
    } ) => {
        /* $(#[$m])* #[derive(...)] $vis enum ... */
        /* impl: ALL, const fn as_str (match *self) */
        /* impl FromStr: 絶対パス ::std::... で書く */
        /* const _: () = assert_distinct(&[ $( $s ),* ]); */
    };
}

✅ 模範解答

📋 コピーmacro_rules! str_enum {
    (
        $(#[$m:meta])*
        $vis:vis enum $name:ident {
            $( $(#[$vm:meta])* $var:ident => $s:literal ),* $(,)?
        }
    ) => {
        $(#[$m])*
        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
        $vis enum $name { $( $(#[$vm])* $var ),* }

        impl $name {
            pub const ALL: &'static [$name] = &[ $( $name::$var ),* ];
            pub const fn as_str(&self) -> &'static str {
                match *self { $( $name::$var => $s ),* }
            }
        }
        impl ::std::str::FromStr for $name {
            type Err = String;
            fn from_str(x: &str) -> ::std::result::Result<Self, String> {
                match x {
                    $( $s => ::std::result::Result::Ok($name::$var), )*
                    _ => ::std::result::Result::Err(format!("unknown {}: {x}", stringify!($name))),
                }
            }
        }
        const _: () = assert_distinct(&[ $( $s ),* ]);
    };
}

const fn str_eq(a: &str, b: &str) -> bool {
    let (a, b) = (a.as_bytes(), b.as_bytes());
    if a.len() != b.len() { return false; }
    let mut i = 0;
    while i < a.len() { if a[i] != b[i] { return false; } i += 1; }
    true
}
const fn assert_distinct(xs: &[&str]) {
    let mut i = 0;
    while i < xs.len() {
        let mut j = i + 1;
        while j < xs.len() {
            if str_eq(xs[i], xs[j]) { panic!("str_enum!: duplicate string"); }
            j += 1;
        }
        i += 1;
    }
}

str_enum! {
    /// log level
    #[derive(PartialOrd, Ord)]
    pub enum Level {
        /// verbose
        Debug => "debug",
        Info => "info",
    }
}
str_enum! { enum Empty {} }

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::HashSet;
    #[test] fn roundtrip() {
        for &v in Level::ALL { assert_eq!(v.as_str().parse::<Level>(), Ok(v)); }
        assert_eq!(Level::ALL.len(), 2);
        assert!(Level::Debug < Level::Info);
    }
    #[test] fn unknown() { assert_eq!("x".parse::<Level>().unwrap_err(), "unknown Level: x"); }
    #[test] fn hashable() { let s: HashSet<Level> = Level::ALL.iter().copied().collect(); assert_eq!(s.len(), 2); }
    #[test] fn empty() { assert!(Empty::ALL.is_empty()); }
    const NAME: &str = Level::Info.as_str();   // const fn
    #[test] fn constfn() { assert_eq!(NAME, "info"); }
}
fn main() { println!("{:?}", "info".parse::<Level>()); }

実行結果（出題者の環境: rustc 1.96.0 / cargo 1.96.0、edition 2024）:

📋 コピーrunning 5 tests
test tests::empty ... ok
test tests::constfn ... ok
test tests::roundtrip ... ok
test tests::hashable ... ok
test tests::unknown ... ok
test result: ok. 5 passed; 0 failed

Part 1 の答え（元の PR に対して、実際にコンパイルして確認した結果）

先輩の予想が外れた箇所（出題者も予想を外した）

出題者も当初「$s:expr で受けた式はパターンに置けないので、元の PR は定数パスでなくても落ちる」と考えていました。実測は逆でした。

• 元の PR の $s:expr は、"debug" のような文字列リテラルなら、パターンの位置に置いてもコンパイルが通る（Part 1 の PR がそのまま通っている）。落ちるのは、定数のパス（U5）やメソッド呼び出し（U6）のとき
• U8 の levels! は、$s:expr で受けた "debug" を str_enum! に転送しても通る。修正後の $s:literal 版でも通る（実測）。「expr で受けたら literal に渡せない」は、リテラルに限っては成り立たなかった
• つまり、元の PR の欠陥は「リテラルしか通らないのに、型は expr と名乗っている」という約束と実装のずれ。リテラルだけを試したテストでは検出できない

修正後に定数パス A を渡すと error: no rules expected 'A' になり、エラーの位置が「パターンの中」から「マクロの入口」に移ります（実測）。-1 を渡したときは E0308 mismatched types（文字列ではないので当然）で、literal でも expr でも防げません。型の整合は as_str の戻り値の型が見張っています。

🔍 Step-by-Step 解説

Step 1: テストが通ることと、入力を受け付けることは別

元のテスト3つは「variant 3 個・末尾カンマなし・属性なし・重複なし・リテラル」という1通りの入力しか使っていません。マクロのテストは、入力の形のバリエーション（U1〜U8 のような）を書かないと、利用者が最初に踏む穴を見逃します。

Step 2: 属性は $(#[$m:meta])* で通す

/// は #[doc = "..."] になるので、meta で受ければ doc コメントも #[derive(...)] も同じ部品で通ります。出力では $(#[$m])* と書けば元の位置にそのまま戻ります。

Step 3: 重複は const の panic でコンパイルエラーにする

unreachable_patterns は警告で、CI で -D warnings にしていなければ通ってしまいます。const _: () = assert_distinct(&[...]); にすれば、重複の入力は E0080 evaluation panicked: str_enum!: duplicate string になり、コンパイルが止まります（実測）。&str の == は const fn で使えない（理解している範囲。今回は as_bytes() で比べる方法だけを実行して確認した）ので、バイト列を while で比べています。

Step 4: 0 variant と const fn

match *self {} にすると、0 variant でも通ります（Copy が前提）。as_str を const fn にしたので、const NAME: &str = Level::Info.as_str(); が書けます（テスト constfn）。

Step 5: 絶対パスで書く

FromStr・Result・Ok・Err を ::std::... で書いています。利用者が自分のクレートで Result を別の型にしていても壊れません（Day 058 の「絶対パス」の欠陥と同じ種類。今回は別名 Result での実測はしていない）。

🧭 設計思想・なぜこう書くのか

macro_rules! の本質は字句の並びのパターンマッチで、型検査は展開した後に起きます。だから、利用者に向けた約束（どんな入力を受け付けるか）は、パターンの書き方そのものです。$s:expr と書けば「式なら何でも」と約束したことになり、$s:literal と書けば「リテラルだけ」と約束します。実装がパターン位置に置く以上、本当の約束は後者なので、約束と実装を一致させるのが正しい直し方です。

Rust は「ゼロコスト」と「コンパイル時に潰す」を好むので、重複の検出も実行時のテストではなく const の評価で行います。ここで unreachable_patterns の警告に頼らず const _ で止めているのは、警告は無視できるが、エラーは無視できないからです。

迷った他案と採らなかった理由

🛠 コンパイルエラーが出た場合（デバッグ問題では必須）

エラー1: U1 の末尾カンマ

読み方: note: while trying to match が、パターンのどの部品で止まったかを指している。ここでは「, の後なのでもう1つ $var:ident が来るはず」。直し方は $(,)? を足す。

エラー2: U2 / U3 の doc コメント

読み方: コンパイラが /// を #[doc] に展開したことまで教えてくれる。$(#[$m:meta])* を足す。

エラー3: U5 の定数パス

読み方: エラーの位置は呼び出し側の A を指している。マクロの中身ではなく、展開されたパターンが問題。literal に変えるか、FromStr を if x == $s の連鎖に変える。

エラー4: U7 の 0 variant

読み方: 空の enum でも、&L（参照）は「非空の型」とみなされる。match *self {} にする。

エラー5: 重複を const で止めた場合

エラー6: 利用者が #[derive(Debug)] を書き足した場合（D2）

🔁 他言語との比較（該当する場合）

🏭 実務での使いどころ

• 設定のキー、ログレベル、HTTP メソッド、状態列（"pending" / "done"）のように、閉じた集合を文字列で保存する型。variant を足すとき、FromStr の腕を足し忘れる事故を型で防ぐ
• 外部クレートを増やしたくない小さなツール・組み込みの現場では、50 行のマクロで足りることがある。一方、公開 API や serde と組むなら strum・serde の derive の方が約束が明確
• マクロを公開するときは、末尾カンマ・属性・0 件・重複の4つを最初のテストに入れる

⚠️ よくある誤解・ミス

📖 一次資料（参照日: 2026-10-03。今回は取得し直して照合していません。記述は各資料の要旨であり、原文の引用ではありません）

• The Rust Reference「Macros By Example」— Metavariables と Fragment Specifiers（expr・literal・meta）、follow-set — doc.rust-lang.org/reference/macros-by-example.html
• The Rust Reference「Patterns」— パターンに置けるもの（リテラル・パス・範囲）— doc.rust-lang.org/reference/patterns.html
• strum（Peternator7/strum）— EnumString・AsRefStr の仕様 — github.com/Peternator7/strum（star 数・ライセンス・push 日は GitHub API の実測。derive の細かな挙動は未確認）

🚧 今日扱わなかった範囲（次回以降）

3 問の自己点検（/ai-smell-audit 相当）

1. 同じ指示を AI に出せば数時間で出るか — str_enum! 自体は出る。ただし「$s:expr のリテラルはパターンに通る」は出題者が予想を外して実機で初めて分かった（記録として本文に残した）。
2. AI に指示するだけでは出ない部分 — U1〜U8 の実測表（エラー文・警告の有無）、予想が外れた記録、strum の star 数などの出所つきの数値、採らなかった案の表。
3. 世界の実物と比べた扱った割合 — strum は derive が複数ある（EnumString・Display・EnumIter 等。正確な数は数えていない）うち、文字列との往復1点だけ。1 割未満と見積もる（導出、数えていない）。

➡️ 次のステップ

• 発展: strum を入れて U1〜U8 を同じ入力で通し、挙動の違いを表にする（今日は未実施）
• 次回予告: （state の次回予告のまま）マクロ① の5問目（設計・アーキテクチャ）— 「マクロにするか、関数・型にするか」を既出のマクロで判断する

🎯 自己評価（解いた後に記入）

自分の回答

気づき・メモ