Method cast

src/analysis/memory/symbolic_value.rs:702–750

(&self, target_type: ExpressionType)

    }

    fn cast(&self, target_type: ExpressionType) -> Rc<SymbolicValue> {
        match &self.expression {
            Expression::CompileTimeConstant(v1) => {
                let result = v1.cast(&target_type);
                if result != ConstantValue::Bottom {
                    return Rc::new(result.into());
                } else {
                    self.clone()
                }
            }
            Expression::Bottom => self.clone(),
            Expression::Join { left, right } => {
                left.cast(target_type.clone()).join(right.cast(target_type))
            }
            _ => {
                match &self.expression {
                    // [(x as t1) as target_type] -> x as target_type if t1.max_value() >= target_type.max_value()
                    Expression::Cast {
                        operand,
                        target_type: t1,
                    } => {
                        if t1.is_integer()
                            && target_type.is_unsigned_integer()
                            && t1
                                .max_value()
                                .greater_or_equal(&target_type.max_value())
                                .as_bool_if_known()
                                .unwrap_or(false)
                        {
                            return operand.cast(target_type);
                        }
                    }
                    _ => (),
                }
                if self.expression.infer_type() != target_type {
                    SymbolicValue::make_typed_unary(
                        self.clone(),
                        target_type,
                        |operand, target_type| Expression::Cast {
                            operand,
                            target_type,
                        },
                    )
                } else {
                    self.clone()
                }
            }
        }
    }

    /// Returns an element that is "*self".
    fn dereference(&self, target_type: ExpressionType) -> Rc<SymbolicValue> {