Method dereference

src/analysis/memory/symbolic_value.rs:753–790

Returns an element that is "*self".

(&self, target_type: ExpressionType)

    /// Returns an element that is "*self".
    fn dereference(&self, target_type: ExpressionType) -> Rc<SymbolicValue> {
        match &self.expression {
            Expression::Bottom | Expression::Top => self.clone(),
            Expression::Cast {
                operand,
                target_type: _,
            } => operand.dereference(target_type),
            Expression::CompileTimeConstant(..) => self.clone(),
            Expression::Reference(path) => {
                if let PathEnum::HeapBlock { value } = &path.value {
                    value.clone()
                } else {
                    SymbolicValue::make_from(
                        Expression::Variable {
                            path: path.clone(),
                            var_type: target_type,
                        },
                        1,
                    )
                }
            }
            Expression::Variable { path, .. } => SymbolicValue::make_from(
                Expression::Variable {
                    path: Path::new_qualified(path.clone(), Rc::new(PathSelector::Deref)),
                    var_type: target_type,
                },
                1,
            ),
            Expression::Widen { path, operand } => operand.dereference(target_type).widen(path),
            _ => {
                info!(
                    "found unhandled expression that is of type reference: {:?}",
                    self.expression
                );
                SymbolicValue::make_typed_unknown(target_type)
            }
        }
    }

    /// Returns an element that is "self == other".
    fn equals(&self, other: Rc<SymbolicValue>) -> Rc<SymbolicValue> {