Fix: Handle all escape characters

[KennethKnudsen97]

I think I also need to change the calculation of the length of string

 impl<const T: usize> AtatLen for String<T> {
      const LEN: usize = 1 + T + 1;
  }

To worst case scenario like

impl<const T: usize> AtatLen for String<T> {
      const LEN: usize = 3 * T + 2;  // Worst case: every char escapes to 3 bytes, plus quotes
  }

This will make the size 3 times the size, only to handle the case where every character in the string need to be escaped.

[MathiasKoch]

Hey Kenneth, thanks for tackling the escaping — the serializer logic itself looks correct and the tests are solid.

There's a soundness issue though: the PR doesn't update AtatLen for String<T> (still 1 + T + 1 in atat/src/derive.rs:50-52), so the buffer sized from MAX_LEN can overflow when escaping expands characters. A String<10> full of backslashes would serialize to 32 bytes but the buffer only accounts for 12.

You mentioned the 3 * T + 2 fix in the PR description, and I agree that's the correct worst case — but applying it unconditionally to AtatLen::LEN penalizes every command, even those with escape_strings = false.

An alternative approach: add an ESCAPED_LEN associated constant to the AtatLen trait alongside LEN. For most types they're identical. For String<T>, LEN stays 1 + T + 1 and ESCAPED_LEN becomes 3 * T + 2. The derive macro already knows the escape_strings flag per-command, so it can pick the right constant when computing MAX_LEN:

pub trait AtatLen {
    const LEN: usize;
    const ESCAPED_LEN: usize;
}

// Non-string types: no difference (handled by impl_length! macro)
macro_rules! impl_length {
    ($type:ty, $len:expr) => {
        impl AtatLen for $type {
            const LEN: usize = $len;
            const ESCAPED_LEN: usize = $len;
        }
    };
}

// String: only ESCAPED_LEN pays the 3x cost
impl<const T: usize> AtatLen for String<T> {
    const LEN: usize = 1 + T + 1;
    const ESCAPED_LEN: usize = 3 * T + 2;
}

Wrappers propagate both (Option<T>, &T, Vec<T, L> forward ESCAPED_LEN from the inner type).

Then in atat_derive/src/len.rs, struct_len takes the escape_strings flag and emits <#ty as atat::AtatLen>::ESCAPED_LEN vs ::LEN accordingly. Same for enum_len and the &str with #[at_arg(len = N)] case (3 * N + 2 vs 1 + N + 1).

In cmd.rs, the MAX_LEN computation just uses the escaped variant when escape_strings = true. The existing cmd_len += 2 for escape_strings can be removed since quotes are already part of both LEN and ESCAPED_LEN on string types (it was double-counting before).

Net effect: commands with escape_strings = false see zero buffer overhead. Commands with escape_strings = true only inflate string fields, not the entire struct. A String<128> goes from 130 → 386 only in commands that actually use escaping.

Does that sound like a reasonable approach to you?

[KennethKnudsen97]

That sounds like a good idea :D

[MathiasKoch]

@KennethKnudsen97 Looks good to me now.

Ready for your review

[KennethKnudsen97]

I have reviewed and testet this PR. Everything is good.