Method update_value_at

src/analysis/abstract_domain.rs:246–311

Updates the path to value map so that the given path now points to the given value.

(&mut self, path: Rc<Path>, value: Rc<SymbolicValue>)

    /// Updates the path to value map so that the given path now points to the given value.
    pub fn update_value_at(&mut self, path: Rc<Path>, value: Rc<SymbolicValue>) {
        debug!("Updating value at {:?}, value: {:?}", path, value);

        if value.is_bottom() || value.is_top() {
            self.numerical_domain.forget(&path);
            self.nullness_domain.forget(&path);
            return;
        }

        let nullness = self.infer_reference_nullness(&value);
        self.update_nullness_at(&path, nullness);

        match &value.expression {
            Expression::Numerical(rpath) => {
                self.numerical_domain
                    .assign_var(path.clone(), rpath.clone());
            }
            Expression::CompileTimeConstant(c) => {
                if let Some(i) = c.try_get_integer() {
                    self.numerical_domain.assign_int(path.clone(), i);
                } else {
                    self.numerical_domain.forget(&path);
                }
            }
            Expression::Variable {
                path: rpath,
                var_type,
            } if var_type.is_integer() => {
                self.numerical_domain
                    .assign_var(path.clone(), rpath.clone());
            }
            Expression::Add { left, right } => {
                if !self.assign_integer_binary_expression(
                    path.clone(),
                    NumericalOperation::Add,
                    left,
                    right,
                ) {
                    self.numerical_domain.forget(&path);
                }
            }
            Expression::Sub { left, right } => {
                if !self.assign_integer_binary_expression(
                    path.clone(),
                    NumericalOperation::Sub,
                    left,
                    right,
                ) {
                    self.numerical_domain.forget(&path);
                }
            }
            Expression::Mul { left, right } => {
                if !self.assign_integer_binary_expression(
                    path.clone(),
                    NumericalOperation::Mul,
                    left,
                    right,
                ) {