Function parse_index_name

graphlite/src/ast/parser.rs:4776–4840

Parse index name - lenient parser that accepts various token types for better error messages This allows invalid names to be parsed so we can provide meaningful validation errors

(tokens: &[Token])

/// Parse index name - lenient parser that accepts various token types for better error messages
/// This allows invalid names to be parsed so we can provide meaningful validation errors
fn parse_index_name(tokens: &[Token]) -> IResult<&[Token], String> {
    if let Some(token) = tokens.first() {
        let name = match token {
            // Valid identifier tokens
            Token::Identifier(s) => Some(s.clone()),
            Token::String(s) => Some(s.clone()),

            // Accept integers so we can validate "cannot start with digit" later
            Token::Integer(n) => Some(n.to_string()),
            Token::Float(f) => Some(f.to_string()),

            // Accept keywords that might be used as identifiers
            Token::Value => Some("value".to_string()),
            Token::Type => Some("type".to_string()),
            Token::User => Some("user".to_string()),
            Token::Role => Some("role".to_string()),
            Token::Schema => Some("schema".to_string()),
            Token::Data => Some("data".to_string()),
            Token::Graph => Some("graph".to_string()),
            Token::Node => Some("node".to_string()),
            Token::Edge => Some("edge".to_string()),
            Token::Path => Some("path".to_string()),
            Token::Table => Some("table".to_string()),
            Token::Property => Some("property".to_string()),

            _ => None,
        };

        if let Some(mut name_str) = name {
            let mut remaining = &tokens[1..];

            // Check if next token is a minus sign followed by identifier (e.g., "invalid-name")
            // Consume the pattern to give better error message later
            while let Some(Token::Minus) = remaining.first() {
                if let Some(Token::Identifier(suffix)) = remaining.get(1) {
                    name_str.push('-');
                    name_str.push_str(suffix);
                    remaining = &remaining[2..];
                } else {
                    break;
                }
            }

            // Check if this was an integer followed by underscore and identifier (e.g., "123_invalid")
            // This handles the case where lexer splits it as: Integer(123), Identifier("_invalid")
            if let Token::Integer(_) = token {
                while let Some(Token::Identifier(suffix)) = remaining.first() {
                    if suffix.starts_with('_') {
                        name_str.push_str(suffix);
                        remaining = &remaining[1..];
                    } else {
                        break;
                    }
                }
            }

            return Ok((remaining, name_str));
        }