Method parse_fields

aiscript-runtime/src/parser.rs:166–229

(&mut self)

    }

    fn parse_fields(&mut self) -> Result<Vec<Field>, String> {
        self.consume(TokenType::OpenBrace, "Expected '{' after field block")?;

        let mut fields = Vec::new();
        while !self.check(TokenType::CloseBrace) {
            // Parse doc comments
            let docs = self.parse_docs();

            // Parse validators
            let validators = DirectiveParser::new(&mut self.scanner).parse_validators();

            // Parse field name
            if !self.check(TokenType::Identifier) {
                return Err("Expected field name".to_string());
            }
            let name = self.current.lexeme.to_string();
            self.advance();

            self.consume(TokenType::Colon, "Expected ':' after field name")?;

            // Parse field type
            if !self.check(TokenType::Identifier) {
                return Err("Expected field type".to_string());
            }
            let field_type = match self.current.lexeme {
                "str" => FieldType::Str,
                "int" | "float" => FieldType::Number,
                "bool" => FieldType::Bool,
                _ => return Err(format!("Invalid field type: {}", self.current.lexeme)),
            };
            self.advance();

            // Parse default value
            let mut default = None;
            if self.check(TokenType::Equal) {
                self.advance();
                default = Some(self.parse_value()?);
            }

            fields.push(Field {
                name,
                _type: field_type,
                required: default.is_none(),
                default,
                validators: validators.into_boxed_slice(),
                docs,
            });

            // If this is not the last field (not followed by a closing brace),
            // then a comma is required
            if !self.check(TokenType::CloseBrace) {
                self.consume(TokenType::Comma, "Expected ',' after field definition")?;
            } else {
                // We've reached the closing brace, we can optionally have a comma
                if self.check(TokenType::Comma) {
                    self.advance(); // consume the optional trailing comma
                }
                break;