pub(crate) fn check_placeholder(&mut self, placeholder: &Placeholder) {
        self.placeholders += 1;  // Track placeholder processing count
    
        let expr = placeholder.expr(); // Extract expression inside placeholder
    
        // Evaluate the placeholder expression and check that the resulting type is
        // coercible to string for interpolation
        if let Some(ty) = self.evaluate_expr(&expr) {
            match ty {
                // If the type is already coercible, do nothing
                Type::Primitive(..) | Type::Union | Type::None => {
                    // Validate primitive types with their options
                    if let Some(option) = placeholder.option() {
                        let valid = match option {
                            PlaceholderOption::Sep(_) => false, // Sep option is not valid for primitives
                            PlaceholderOption::Default(_) => matches!(ty, Type::Primitive(_, true)),
                            PlaceholderOption::TrueFalse(_) => matches!(ty, Type::Primitive(PrimitiveType::Boolean, _)),
                        };
                        
                        if !valid {
                            self.context.add_diagnostic(
                                Self::invalid_placeholder_option(&ty, expr.span(), Some(option))
                            );
                        }
                    } else {
                        // Apply cannot_coerce_to_string if no option is specified
                        self.context.add_diagnostic(cannot_coerce_to_string(&ty, expr.span()));
                    }
                }
    
                // Otherwise, check placeholder options
                _ => {
                    let coercible = match placeholder.option() {
                        // `Sep` option: Only `Array[P]` where `P` is a non-optional primitive or Union is valid
                        Some(PlaceholderOption::Sep(_)) => matches!(ty, 
                            Type::Compound(CompoundType::Array(ref element_type), false) // Enforcing non-optional Array
                            if matches!(element_type.element_type(), Type::Primitive(_, false) | Type::Union)),
    
                        // `Default` option: Only optional primitive types are valid
                        Some(PlaceholderOption::Default(_)) => matches!(ty, 
                            Type::Primitive(_, true)),
    
                        // `TrueFalse` option: Only Boolean type is valid
                        Some(PlaceholderOption::TrueFalse(_)) => matches!(ty, 
                            Type::Primitive(PrimitiveType::Boolean, _)),
    
                        None => false, // Apply cannot_coerce_to_string if no option is specified
                    };
                    if !coercible {
                        self.context
                            .add_diagnostic(
                                Self::invalid_placeholder_option(&ty, expr.span(), placeholder.option())
                                
                            );
                    }
                }
            }
        }
    
        self.placeholders -= 1;
    }

/// Generates a diagnostic message for invalid placeholder options.
fn invalid_placeholder_option(ty: &Type, span: Span, option: Option<PlaceholderOption>) -> Diagnostic {
    let message = match option {
        Some(PlaceholderOption::Sep(_)) => format!(
            "type mismatch for placeholder option `sep`: expected type `Array[P]` where P: any primitive type or Union, but found `{}`", ty
        ),
        Some(PlaceholderOption::Default(_)) => format!(
            "type mismatch for placeholder option `default`: expected an optional primitive type, but found `{}`", ty
        ),
        Some(PlaceholderOption::TrueFalse(_)) => format!(
            "type mismatch for placeholder option `truefalse`: expected type `Boolean`, but found `{}`", ty
        ),
        None => "Unexpected type for placeholder".to_string(),
    };
    
    return Diagnostic::error(message);
}

    

    /// Evaluates the type of a literal array expression.
    fn evaluate_literal_array(&mut self, expr: &LiteralArray) -> Type {
        // Look at the first array element to determine the element type
        // The remaining elements must have a common type
        let mut elements = expr.elements();
        match elements
            .next()
            .and_then(|e| Some((self.evaluate_expr(&e)?, e.span())))
        {
            Some((mut expected, mut expected_span)) => {
                // Ensure the remaining element types share a common type
                for expr in elements {
                    if let Some(actual) = self.evaluate_expr(&expr) {
                        if let Some(ty) = expected.common_type(&actual) {
                            expected = ty;
                            expected_span = expr.span();
                        } else {
                            self.context.add_diagnostic(no_common_type(
                                &expected,
                                expected_span,
                                &actual,
                                expr.span(),
                            ));
                        }
                    }
                }

                ArrayType::non_empty(expected).into()
            }
            // Treat empty array as `Array[Union]`
            None => ArrayType::new(Type::Union).into(),
        }
    }