GitoxideLabs/gitoxide · warning

attr itself

Error message

attr itself

What it means

`parse_attr` splits an attribute assignment at the first `=` with `splitn(2, ...)`. The first element (the attribute name) always exists for any non-empty input, so `tokens.next()` is expected to be `Some`; the `.expect("attr itself")` panics only on empty input reaching this function, indicating a caller bug.

Solutions

1. Filter out empty attribute segments before calling `parse_attr`.
2. Update gitoxide so blank-token filtering upstream prevents empty attrs from reaching `parse_attr`.
3. Replace the `.expect()` with an early `return Err` on empty input for a clean error.

Example fix

// before
let attr = tokens.next().expect("attr itself").as_bstr();

// after
let Some(attr) = tokens.next() else {
    return Err(name::Error { attribute: attr.into() });
};
let attr = attr.as_bstr();

// skip empty segments before parse_attr
if attr.is_empty() {
    continue; // or return a parse error
}

match parse_attr(attr) {
    Ok(assignment) => push(assignment),
    Err(e) => return Err(e),
}

When it happens

Trigger: Calling `parse_attr` with an empty attribute slice, or a regression where `attrs` (produced by `input.split(is_blank)`) yields empty segments that reach this function.

Common situations: Malformed `.gitattributes` lines with stray blank tokens (e.g. double spaces or trailing whitespace) if upstream filtering changes; contributors refactoring the parser.

Understand the failure class

Background: "This is a bug, please report it": internal invariant violations, unreachable panics, and SNH errors explained — this error's family across 47 libraries.

Related errors

• cannot find character that we didn't search for
• parser must have set some object value
• successful iteration has outcome
• valid ASCII
• every parent is set only once

AI-assisted analysis of GitoxideLabs/gitoxide@e73179060b (2026-09-08). Data as JSON: /api/errors/ffb245509c9ab017. Report an issue: GitHub.

Appendix: source

Thrown at gix-attributes/src/parse.rs:54

    line_no: usize,
}

/// An iterator over attribute assignments in a single line.
pub struct Iter<'a> {
    attrs: std::slice::Split<'a, u8, fn(&u8) -> bool>,
}

impl<'a> Iter<'a> {
    /// Create a new instance to parse attribute assignments from `input`.
    pub fn new(input: &'a BStr) -> Self {
        Iter {
            attrs: input.split(is_blank as fn(&u8) -> bool),
        }
    }

    fn parse_attr(&self, attr: &'a [u8]) -> Result<AssignmentRef<'a>, name::Error> {
        let mut tokens = attr.splitn(2, |b| *b == b'=');
        let attr = tokens.next().expect("attr itself").as_bstr();
        let possibly_value = tokens.next();
        let (attr, state) = if attr.first() == Some(&b'-') {
            (&attr[1..], StateRef::Unset)
        } else if attr.first() == Some(&b'!') {
            (&attr[1..], StateRef::Unspecified)
        } else {
            (attr, possibly_value.map_or(StateRef::Set, StateRef::from_bytes))
        };
        Ok(AssignmentRef::new(check_attr(attr)?, state))
    }
}

fn check_attr(attr: &BStr) -> Result<NameRef<'_>, name::Error> {
    NameRef::try_from(attr).and_then(|name| {
        (!name.as_str().starts_with("builtin_"))
            .then_some(name)
            .ok_or_else(|| name::Error { attribute: attr.into() })
    })

View on GitHub (pinned to e73179060b)