Upgrade `ValueOrRef`.

This now uses a Weak reference instead of a reference. The problem with references are lifetimes, with a Weak reference no life time has to be leaked everywhere.

If the Weak reference is not longer in memory, `Value::Nil` is used instead.

Cargo.lock

@@ -3190,7 +3190,6 @@ dependencies = [
  "futures",
  "hmac",
  "num",
- "parking_lot",
  "pest",
  "pest_derive",
  "rand",

utxo/Cargo.toml

@@ -12,7 +12,6 @@ derive_more = "0.99.17"
 futures = { version = "0.3.30", optional = true }
 hmac = "0.12.1"
 num = "0.4.3"
-parking_lot = "0.12.2"
 rand = "0.8.5"
 pest = { version = "2.7.10" }
 pest_derive = "2.7.10"

utxo/src/filter_expr/compiler/mod.rs

@@ -41,9 +41,12 @@ impl<'a> Compiler<'a> {
     ) -> Result<Vec<OpCode>, Error> {
         Ok(match expr {
             Expr::Variable(name) => vec![OpCode::LOAD_EXTERNAL(return_to, name.clone())],
-            Expr::Bool(value) => vec![OpCode::LOAD(return_to, Value::Bool(*value))],
-            Expr::String(string) => vec![OpCode::LOAD(return_to, Value::String(string.clone()))],
-            Expr::Number(number) => vec![OpCode::LOAD(return_to, Value::Number(*number))],
+            Expr::Bool(value) => vec![OpCode::LOAD(return_to, Value::Bool(*value).into())],
+            Expr::String(string) => vec![OpCode::LOAD(
+                return_to,
+                Value::String(string.clone()).into(),
+            )],
+            Expr::Number(number) => vec![OpCode::LOAD(return_to, Value::Number(*number).into())],
             Expr::Op { op, terms } => {
                 let mut opcodes = vec![];
                 let current_exit_label = self.next_label();
@@ -122,7 +125,7 @@ impl<'a> Compiler<'a> {
                         return Ok(opcodes);
                     }
                     ExprOp::Or | ExprOp::And => {
-                        opcodes = vec![OpCode::LOAD(return_to, Value::Bool(false))];
+                        opcodes = vec![OpCode::LOAD(return_to, Value::Bool(false).into())];
 
                         let terms = terms
                             .iter()

utxo/src/filter_expr/compiler/optimizations/calculate_static_values.rs

@@ -1,5 +1,5 @@
 use crate::filter_expr::{opcode::OpCode, Value};
-use std::collections::HashMap;
+use std::{collections::HashMap, rc::Rc};
 
 /// Executes operations that can be performed at compile time, and sets the initial_register to
 /// the result. This is useful for optimizing the program, by executing at `compile` time as
@@ -39,13 +39,13 @@ pub fn calculate_static_values(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool)
                 register.remove(dst);
             }
             OpCode::JEQ(reg, addr) => {
-                if let Some(Value::Bool(true)) = register.get(reg) {
+                if register.get(reg).map(|x| x.is_true()).unwrap_or_default() {
                     *opcode = OpCode::JMP(*addr);
                     has_changed = true;
                 }
             }
             OpCode::JNE(reg, addr) => {
-                if let Some(Value::Bool(false)) = register.get(reg) {
+                if register.get(reg).map(|x| x.is_false()).unwrap_or_default() {
                     *opcode = OpCode::JMP(*addr);
                     has_changed = true;
                 }
@@ -64,22 +64,22 @@ pub fn calculate_static_values(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool)
                     return;
                 };
                 let result = value1 == value2;
-                *opcode = OpCode::LOAD(*dst, result.into());
+                *opcode = OpCode::LOAD(*dst, Rc::new(result.into()));
                 has_changed = true;
             }
             OpCode::MUL(dst, reg1, reg2)
             | OpCode::SUB(dst, reg1, reg2)
             | OpCode::DIV(dst, reg1, reg2)
             | OpCode::ADD(dst, reg1, reg2) => {
-                let number1 = match register.get(reg1) {
-                    Some(Value::Number(number)) => *number,
+                let number1 = match register.get(reg1).map(|value| value.as_number()) {
+                    Some(Ok(number)) => number,
                     _ => {
                         register.remove(dst);
                         return;
                     }
                 };
-                let number2 = match register.get(reg2) {
-                    Some(Value::Number(number)) => *number,
+                let number2 = match register.get(reg2).map(|value| value.as_number()) {
+                    Some(Ok(number)) => number,
                     _ => {
                         register.remove(dst);
                         return;
@@ -94,7 +94,7 @@ pub fn calculate_static_values(mut opcodes: Vec<OpCode>) -> (Vec<OpCode>, bool)
                     OpCode::DIV(_, _, _) => number1.checked_div(number2).map(Value::Number),
                     _ => None,
                 } {
-                    *opcode = OpCode::LOAD(*dst, calculated_value);
+                    *opcode = OpCode::LOAD(*dst, calculated_value.into());
                     has_changed = true;
                 }
             }

utxo/src/filter_expr/filter.rs

@@ -8,10 +8,10 @@ use super::{
     Addr, Error, Register,
 };
 use crate::Transaction;
-use std::collections::HashMap;
+use std::{collections::HashMap, rc::Rc};
 
 #[derive(Debug, Clone)]
-pub struct Filter<'a> {
+pub struct Filter {
     /// Query
     expr: Option<Expr>,
     /// List of external variables
@@ -23,17 +23,16 @@ pub struct Filter<'a> {
     /// The list of opcodes that make up the program, the labels has been converted into addresses
     opcodes_to_execute: Vec<OpCode>,
     /// The state of the register
-    pub(crate) initial_register: HashMap<Register, ValueOrRef<'a>>,
-    _phantom: std::marker::PhantomData<&'a ()>,
+    pub(crate) initial_register: HashMap<Register, ValueOrRef>,
 }
 
-impl<'a> Filter<'a> {
+impl Filter {
     pub fn new(code: &str) -> Result<Self, Error> {
         let expr = parse(code)?;
         let opcodes = expr.as_ref().map_or_else(
             || {
                 Ok(vec![
-                    OpCode::LOAD(0.into(), true.into()),
+                    OpCode::LOAD(0.into(), Rc::new(true.into())),
                     OpCode::HLT(0.into()),
                 ])
             },
@@ -53,7 +52,6 @@ impl<'a> Filter<'a> {
                 .collect(),
             opcodes_to_execute: Compiler::resolve_label_to_addr(opcodes)?,
             initial_register: HashMap::new(),
-            _phantom: std::marker::PhantomData,
         };
         Ok(instance.optimize())
     }
@@ -97,8 +95,8 @@ impl<'a> Filter<'a> {
     }
 
     pub fn execute(
-        &'a self,
-        external_variables: &'a HashMap<Variable, ValueOrRef<'a>>,
+        &self,
+        external_variables: &HashMap<Variable, ValueOrRef>,
     ) -> Result<Value, Error> {
         execute(
             external_variables,

utxo/src/filter_expr/opcode.rs

@@ -1,4 +1,5 @@
 use super::{expr::Variable, value::Value, Addr, Register};
+use std::rc::Rc;
 
 #[derive(Clone, Debug, PartialEq)]
 /// OpCode for a register based virtual machine
@@ -9,7 +10,7 @@ pub enum OpCode {
     // Data Movement Instructions
     /// LOAD <destination> <value>
     /// Load a value into a register.
-    LOAD(Register, Value),
+    LOAD(Register, Rc<Value>),
 
     /// Request an external source for a given information
     /// LOAD <destination> <value>

utxo/src/filter_expr/runtime.rs

@@ -33,10 +33,22 @@ macro_rules! set {
 }
 
 #[inline]
-pub fn execute<'a>(
-    external_variables: &'a HashMap<Variable, ValueOrRef<'a>>,
-    code: &'a [OpCode],
-    initial_registers: HashMap<Register, ValueOrRef<'a>>,
+/// Execute the program
+///
+/// Executes the program passing the external variables and the initial registers.
+///
+/// The external variables is a reference to a hashmap that contains the
+/// external variables, if the program attempts to load a variable that does not
+/// exists will return an error immediately.
+///
+/// The initial registers is a hashmap that contains the initial state of the
+/// registers, this is a tool available for the compiler to execute the initial
+/// LOAD, if it makes sense, and pass over the initial state of the registers to
+/// the program, avoiding executing the same opcodes over and over
+pub fn execute(
+    external_variables: &HashMap<Variable, ValueOrRef>,
+    code: &[OpCode],
+    initial_registers: HashMap<Register, ValueOrRef>,
 ) -> Result<Value, Error> {
     let mut execution: Addr = 0.into();
     let mut registers = initial_registers;
@@ -181,9 +193,10 @@ pub fn execute<'a>(
             OpCode::HLT(return_register) => {
                 return registers
                     .remove(return_register)
-                    .map(|x| x.into())
+                    .map(|x| (*x).clone())
                     .ok_or_else(|| Error::EmptyRegister(return_register.to_owned()));
             }
+            x => panic!("Unimplemented opcode: {:?}", x),
         }
 
         execution.next();

utxo/src/filter_expr/tests/mod.rs

@@ -4,7 +4,7 @@ use std::collections::HashMap;
 
 fn external_variables<K: Into<Variable>, V: Into<Value>>(
     external_variables: Vec<(K, V)>,
-) -> HashMap<Variable, ValueOrRef<'static>> {
+) -> HashMap<Variable, ValueOrRef> {
     external_variables
         .into_iter()
         .map(|(k, v)| (k.into(), ValueOrRef::Value(v.into())))

utxo/src/filter_expr/value.rs

@@ -8,7 +8,10 @@ use crate::{
 };
 use chrono::{DateTime, Utc};
 use num::CheckedAdd;
-use std::ops::{Add, Deref};
+use std::{
+    ops::{Add, Deref},
+    rc::{Rc, Weak},
+};
 
 #[derive(Clone, Debug, PartialEq, PartialOrd)]
 pub enum Value {
@@ -73,10 +76,27 @@ impl Value {
             Value::Bool(b) => Ok(*b),
             Value::Nil => Ok(false),
             Value::Number(x) => Ok(*x > 0),
+            /// TODO: Throw an error . Add types for convertion errors
             _ => panic!("Cannot convert to bool"),
         }
     }
 
+    /// Checks if the value is TRUE, any other value will return FALSE.
+    pub fn is_true(&self) -> bool {
+        match self {
+            Value::Bool(b) => *b,
+            _ => false,
+        }
+    }
+
+    /// Checks if the value is FALSE, any other value will return FALSE.
+    pub fn is_false(&self) -> bool {
+        match self {
+            Value::Bool(b) => *b == false,
+            _ => false,
+        }
+    }
+
     pub fn as_number(&self) -> Result<i128, Error> {
         match self {
             Value::Number(x) => Ok(*x),
@@ -108,63 +128,60 @@ impl CheckedAdd for Value {
     }
 }
 
-#[derive(Debug, PartialOrd)]
+#[derive(Debug, Clone)]
 /// Value or reference to a value.
 ///
-/// A reference to a value is being used to avoid cloning from the source code to the registers,
-/// instead to just use a readonly reference
-pub enum ValueOrRef<'a> {
-    Ref(&'a Value),
+/// This is a sorf of attempt to avoid cloning from the source code to the
+/// registers, specially when the value is being defined in the source code,
+/// instead
+/// a Weak reference is being used to avoid cloning the value.
+pub enum ValueOrRef {
+    WeakRef(Weak<Value>),
     Value(Value),
 }
 
-impl PartialEq for ValueOrRef<'_> {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (ValueOrRef::Ref(a), ValueOrRef::Ref(b)) => a == b,
-            (ValueOrRef::Value(a), ValueOrRef::Value(b)) => a == b,
-            (ValueOrRef::Ref(a), ValueOrRef::Value(b)) => *a == b,
-            (ValueOrRef::Value(a), ValueOrRef::Ref(b)) => a == *b,
-        }
-    }
-}
+impl Deref for ValueOrRef {
+    type Target = Value;
 
-impl<'a> Clone for ValueOrRef<'a> {
-    fn clone(&self) -> Self {
+    fn deref(&self) -> &Self::Target {
         match self {
-            ValueOrRef::Ref(value) => ValueOrRef::Value((*value).clone()),
-            ValueOrRef::Value(value) => ValueOrRef::Value(value.clone()),
+            ValueOrRef::WeakRef(value) => {
+                if let Some(rc_value) = value.upgrade() {
+                    unsafe { &*(Rc::into_raw(rc_value) as *const Value) }
+                } else {
+                    &Value::Nil
+                }
+            }
+            ValueOrRef::Value(v) => v,
         }
     }
 }
 
-impl<'a> Into<Value> for ValueOrRef<'a> {
-    fn into(self) -> Value {
-        match self {
-            ValueOrRef::Ref(value) => value.clone(),
-            ValueOrRef::Value(value) => value,
-        }
+impl PartialEq for ValueOrRef {
+    fn eq(&self, other: &Self) -> bool {
+        self.deref() == other.deref()
     }
 }
 
-impl Deref for ValueOrRef<'_> {
-    type Target = Value;
+impl PartialOrd for ValueOrRef {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        self.partial_cmp(other)
+    }
+}
 
-    fn deref(&self) -> &Self::Target {
-        match self {
-            ValueOrRef::Ref(value) => *value,
-            ValueOrRef::Value(value) => &value,
-        }
+impl From<Rc<Value>> for ValueOrRef {
+    fn from(value: Rc<Value>) -> Self {
+        ValueOrRef::WeakRef(Rc::downgrade(&value))
     }
 }
 
-impl<'a> From<&'a Value> for ValueOrRef<'a> {
-    fn from(value: &'a Value) -> Self {
-        ValueOrRef::Ref(value)
+impl From<&Rc<Value>> for ValueOrRef {
+    fn from(value: &Rc<Value>) -> Self {
+        ValueOrRef::WeakRef(Rc::downgrade(&value))
     }
 }
 
-impl<'a> From<Value> for ValueOrRef<'a> {
+impl From<Value> for ValueOrRef {
     fn from(value: Value) -> Self {
         ValueOrRef::Value(value)
     }