Method resolve_val

cel/src/objects.rs:1006–1548

(
        expr: &'a Expression,
        ctx: &'a Context<'a>,
    )

    #[inline(always)]
    pub fn resolve_val<'a>(
        expr: &'a Expression,
        ctx: &'a Context<'a>,
    ) -> Result<Cow<'a, dyn Val>, ExecutionError> {
        match &expr.expr {
            Expr::Literal(literal) => Ok(literal.to_val()),
            Expr::Call(call) => {
                // START OF SPECIAL CASES FOR operators::...
                if call.args.len() == 3 && call.func_name == operators::CONDITIONAL {
                    let cond = Value::resolve_val(&call.args[0], ctx);
                    return if try_bool(cond)? {
                        Value::resolve_val(&call.args[1], ctx)
                    } else {
                        Value::resolve_val(&call.args[2], ctx)
                    };
                }
                if call.args.len() == 2 {
                    match call.func_name.as_str() {
                        operators::LOGICAL_OR => {
                            let left = try_bool(Value::resolve_val(&call.args[0], ctx));
                            return if Ok(true) == left {
                                Ok(Cow::<dyn Val>::Owned(Box::new(CelBool::from(true))))
                            } else {
                                let right = Value::resolve_val(&call.args[1], ctx)?
                                    .downcast_ref::<CelBool>()
                                    .map(|b| *b.inner());
                                match (left, right) {
                                    (Ok(false), Some(right)) => {
                                        Ok(Cow::<dyn Val>::Owned(Box::new(CelBool::from(right))))
                                    }
                                    (Err(_), Some(true)) => {
                                        Ok(Cow::<dyn Val>::Owned(Box::new(CelBool::from(true))))
                                    }
                                    (left, _) => Err(left.err().unwrap_or(NoSuchOverload)),
                                }
                            };
                        }
                        operators::LOGICAL_AND => {
                            let left = try_bool(Value::resolve_val(&call.args[0], ctx));
                            return if Ok(false) == left {
                                Ok(Cow::<dyn Val>::Owned(Box::new(CelBool::from(false))))
                            } else {
                                let right = Value::resolve_val(&call.args[1], ctx)?
                                    .downcast_ref::<CelBool>()
                                    .map(|b| *b.inner());
                                match (left, right) {
                                    (Ok(true), Some(right)) => {
                                        Ok(Cow::<dyn Val>::Owned(Box::new(CelBool::from(right))))
                                    }
                                    (Err(_), Some(false)) => {
                                        Ok(Cow::<dyn Val>::Owned(Box::new(CelBool::from(false))))
                                    }
                                    (left, _) => Err(left.err().unwrap_or(NoSuchOverload)),
                                }
                            };
                        }
                        operators::EQUALS => {
                            return Ok(bool(