Function cast_expression_or_error

crates/gitql-parser/src/parse_cast.rs:72–124

(
    expr: Box<dyn Expr>,
    target_type: Box<dyn DataType>,
    location: SourceLocation,
)

}

fn cast_expression_or_error(
    expr: Box<dyn Expr>,
    target_type: Box<dyn DataType>,
    location: SourceLocation,
) -> Result<Box<dyn Expr>, Box<Diagnostic>> {
    // Check if it's possiable to perform implicit cast directly
    if target_type.has_implicit_cast_from(&expr) {
        return Ok(Box::new(CastExpr {
            value: expr,
            result_type: target_type,
        }));
    }

    // Check if it's supported to cast this value to result type, just return CastExpr
    let value_type: Box<dyn DataType> = expr.expr_type();
    if value_type.equals(&target_type) {
        return Ok(expr);
    }

    let value_expected_types = value_type.can_perform_explicit_cast_op_to();
    if value_expected_types.contains(&target_type) {
        return Ok(Box::new(CastExpr {
            value: expr,
            result_type: target_type,
        }));
    }

    // Check if it's possible to implicit cast the value to one of the expected type of result type
    // then Cast from expected type to the result type
    // Examples: Cast("true" as Int) can be casted as Text -> Bool -> Int
    let expected_types = target_type.can_perform_explicit_cast_op_to();
    for expected_type in expected_types {
        if expected_type.has_implicit_cast_from(&expr) {
            let casting = Box::new(CastExpr {
                value: expr,
                result_type: expected_type.clone(),
            });

            return Ok(Box::new(CastExpr {
                value: casting,
                result_type: target_type,
            }));
        }
    }

    Err(Diagnostic::error(&format!(
        "Unsupported `CAST` operator from type `{}` to type `{}`",
        value_type.literal(),
        target_type.literal(),
    ))
    .with_location(location)
    .as_boxed())
}