Method validate_object_literal

aiscript-vm/src/ty/resolver.rs:148–210

(
        &self,
        class_name: Token<'gc>,
        properties: &[ObjectProperty<'gc>],
    )

    }

    pub fn validate_object_literal(
        &self,
        class_name: Token<'gc>,
        properties: &[ObjectProperty<'gc>],
    ) -> Result<(), Vec<ValidationError<'gc>>> {
        let class_info = self
            .class_info
            .get(class_name.lexeme)
            .ok_or_else(|| vec![ValidationError::ClassNotFound(class_name)])?;

        let mut errors = Vec::new();
        let mut provided_fields = HashSet::new();

        // Check each property
        for prop in properties {
            match prop {
                ObjectProperty::Literal { key, value } => {
                    if let Some(field) = class_info
                        .fields
                        .iter()
                        .find(|f| f.name.lexeme == key.lexeme)
                    {
                        if !provided_fields.insert(key.lexeme) {
                            errors.push(ValidationError::DuplicateField(class_name, *key));
                            continue;
                        }
                        // Type check
                        if self.check_type(value, field.ty).is_err() {
                            errors.push(ValidationError::TypeError {
                                class_token: class_name,
                                field_token: *key,
                                expected_type: field.ty,
                            });
                        }
                    } else {
                        errors.push(ValidationError::InvalidField(class_name, *key));
                    }
                    provided_fields.insert(key.lexeme);
                }
                ObjectProperty::Computed { .. } => {
                    errors.push(ValidationError::ComputedPropertyError(class_name));
                }
            }
        }

        // Check for missing required fields
        let missing_fields: Vec<_> = class_info
            .fields
            .iter()
            .filter(|field| field.required && !provided_fields.contains(field.name.lexeme))
            .map(|field| field.name.lexeme)
            .collect();

        if !missing_fields.is_empty() {
            errors.push(ValidationError::MissingFields(class_name, missing_fields));
        }

        if errors.is_empty() {