Function validate_function_call

graphlite/src/ast/validator.rs:1535–1878

Validate function calls using TypeSpec and TypeValidator

(
    func_call: &FunctionCall,
    ctx: &mut ValidationContext,
    errors: &mut Vec<ValidationError>,
)

/// Validate function calls using TypeSpec and TypeValidator
fn validate_function_call(
    func_call: &FunctionCall,
    ctx: &mut ValidationContext,
    errors: &mut Vec<ValidationError>,
) {
    // Case-insensitive function lookup
    let func_name_upper = func_call.name.to_uppercase();

    // Check if function exists and clone the signature to avoid borrow checker issues
    let signature = match ctx.function_signatures.get(&func_name_upper).cloned() {
        Some(sig) => sig,
        None => {
            errors.push(ValidationError {
                message: format!("Unknown function '{}'", func_call.name),
                location: None,
                error_type: ValidationErrorType::Semantic,
            });
            return;
        }
    };

    // Validate each argument expression
    for arg in &func_call.arguments {
        validate_expression(arg, ctx, errors);
    }

    // For variadic functions (like COUNT), allow flexible argument counts
    if signature.variadic {
        if func_name_upper == "COUNT" {
            // COUNT can have 0 (COUNT(*)) or 1 argument (COUNT(expr))
            if func_call.arguments.len() > 1 {
                errors.push(ValidationError {
                    message: format!(
                        "Function '{}' expects 0 or 1 arguments, got {}",
                        func_call.name,
                        func_call.arguments.len()
                    ),
                    location: None,
                    error_type: ValidationErrorType::Type,
                });
                return;
            }
        }
        // For other variadic functions, just ensure minimum arguments
        if func_call.arguments.len() < signature.argument_types.len() {
            errors.push(ValidationError {
                message: format!(
                    "Function '{}' expects at least {} arguments, got {}",
                    func_call.name,
                    signature.argument_types.len(),
                    func_call.arguments.len()
                ),
                location: None,
                error_type: ValidationErrorType::Type,
            });
        }
        return;
    }