Implement PartialEq and Eq for LuaValue.

This is based on the rules of Lua. Two numbers are equal if they represent
the same mathematical value, and strings are equal if their contents are the
same. In the case of tables, they are equal only if their references are equal.
For example, two different empty tables are not equal.
The `gc` crate had to be extended with a method which checks whether two `gc`s
point to the same object.

Author: rbartlensky

luavm/Cargo.toml

@@ -8,7 +8,7 @@ name = "luavm"
 path = "src/lib/mod.rs"
 
 [dependencies]
-gc = "0.3"
+gc = { git="https://github.com/rbartlensky/rust-gc", branch="ref-eq" }
 gc_derive = "0.3"
 luacompiler = { path="../luacompiler" }
 assert_float_eq = "1.1.3"

luavm/src/lib/errors.rs

@@ -8,4 +8,6 @@ pub enum LuaError {
     IntConversionErr,
     /// Raised when a conversion to float fails.
     FloatConversionErr,
+    /// Raised when a conversion to string fails.
+    StringConversionErr,
 }

luavm/src/lib/lua_values/lua_obj.rs

@@ -4,12 +4,19 @@ use errors::LuaError;
 pub trait LuaObj {
     /// Clones the underlying type, and returns a box of it.
     fn clone_box(&self) -> Box<LuaObj>;
-    /// Checks whether the underlyning type is a float or not.
+    /// Checks whther the underlying type is a float or an int.
+    fn is_number(&self) -> bool;
+    /// Checks whether the underlying type is converted to a float when processed in
+    /// arithmetic expressions.
     fn is_float(&self) -> bool;
+    /// Checks whether the underlying type is a string or not.
+    fn is_string(&self) -> bool;
     /// Converts the underlying type to an int.
     fn to_int(&self) -> Result<i64, LuaError>;
     /// Converts the underlying type to a float.
     fn to_float(&self) -> Result<f64, LuaError>;
+    /// Converts the underlying type to a string.
+    fn to_string(&self) -> Result<String, LuaError>;
 }
 
 /// Boxes the given `LuaObj`, and returns the address of the box.
@@ -32,13 +39,25 @@ impl LuaObj for LuaInt {
         Ok(self.v)
     }
 
+    fn is_number(&self) -> bool {
+        true
+    }
+
     fn is_float(&self) -> bool {
         false
     }
 
+    fn is_string(&self) -> bool {
+        false
+    }
+
     fn to_float(&self) -> Result<f64, LuaError> {
         Ok(self.v as f64)
     }
+
+    fn to_string(&self) -> Result<String, LuaError> {
+        Ok(self.v.to_string())
+    }
 }
 
 pub struct LuaFloat {
@@ -50,17 +69,29 @@ impl LuaObj for LuaFloat {
         Box::new(LuaFloat { v: self.v })
     }
 
+    fn is_number(&self) -> bool {
+        true
+    }
+
     fn is_float(&self) -> bool {
         true
     }
 
+    fn is_string(&self) -> bool {
+        false
+    }
+
     fn to_int(&self) -> Result<i64, LuaError> {
         Err(LuaError::IntConversionErr)
     }
 
     fn to_float(&self) -> Result<f64, LuaError> {
         Ok(self.v)
     }
+
+    fn to_string(&self) -> Result<String, LuaError> {
+        Ok(self.v.to_string())
+    }
 }
 
 pub struct LuaString {
@@ -72,15 +103,27 @@ impl LuaObj for LuaString {
         Box::new(LuaString { v: self.v.clone() })
     }
 
+    fn is_number(&self) -> bool {
+        false
+    }
+
     fn is_float(&self) -> bool {
         true
     }
 
+    fn is_string(&self) -> bool {
+        true
+    }
+
     fn to_int(&self) -> Result<i64, LuaError> {
         self.v.parse().map_err(|_| LuaError::IntConversionErr)
     }
 
     fn to_float(&self) -> Result<f64, LuaError> {
         self.v.parse().map_err(|_| LuaError::FloatConversionErr)
     }
+
+    fn to_string(&self) -> Result<String, LuaError> {
+        Ok(self.v.clone())
+    }
 }

luavm/src/lib/lua_values/mod.rs

@@ -39,6 +39,21 @@ impl LuaVal {
         (LuaValKind::BOXED ^ self.val) as *mut Box<LuaObj>
     }
 
+    fn is_number(&self) -> bool {
+        match self.kind() {
+            LuaValKind::INT | LuaValKind::FLOAT => true,
+            LuaValKind::BOXED => unsafe { (*self.as_boxed()).is_number() },
+            _ => false,
+        }
+    }
+
+    fn is_string(&self) -> bool {
+        match self.kind() {
+            LuaValKind::BOXED => unsafe { (*self.as_boxed()).is_string() },
+            _ => false,
+        }
+    }
+
     /// Returns true if this value can be considered a float, or false otherwise.
     /// This method is only used in arithmetic operations.
     fn is_float(&self) -> bool {
@@ -75,6 +90,18 @@ impl LuaVal {
         }
     }
 
+    /// Attempts to convert this value to a string.
+    pub fn to_string(&self) -> Result<String, LuaError> {
+        match self.kind() {
+            LuaValKind::INT => Ok(((self.val >> tagging::TAG_SHIFT) as i64).to_string()),
+            LuaValKind::FLOAT => {
+                Ok((unsafe { transmute::<usize, f64>(LuaValKind::FLOAT ^ self.val) }).to_string())
+            }
+            LuaValKind::BOXED => unsafe { (*self.as_boxed()).to_string() },
+            _ => Err(LuaError::StringConversionErr),
+        }
+    }
+
     /// Sets this to a new value.
     pub fn set(&mut self, mut val: LuaVal) {
         // exchange the pointers so that when `val` goes out of scope the old value
@@ -155,6 +182,25 @@ impl LuaVal {
     }
 }
 
+impl PartialEq for LuaVal {
+    fn eq(&self, other: &LuaVal) -> bool {
+        if self.is_number() && other.is_number() {
+            return self.to_float().unwrap() == other.to_float().unwrap();
+        } else if self.is_string() && other.is_string() {
+            return self.to_string().unwrap() == other.to_string().unwrap();
+        } else if self.kind() == other.kind() {
+            if self.kind() == LuaValKind::NIL {
+                return true;
+            } else if self.kind() == LuaValKind::TABLE {
+                return unsafe { (*table_ptr(self.val)).same_ptr(&*table_ptr(other.val)) };
+            }
+        }
+        false
+    }
+}
+
+impl Eq for LuaVal {}
+
 impl From<i64> for LuaVal {
     /// Create an integer LuaVal.
     fn from(int: i64) -> Self {
@@ -743,4 +789,65 @@ mod tests {
         float.set(LuaVal::from(2.0));
         assert_ne!(float.to_float().unwrap(), float2.to_float().unwrap());
     }
+
+    fn get_eq_types() -> Vec<LuaVal> {
+        vec![
+            LuaVal::from(1),
+            LuaVal::from(1.0),
+            LuaVal::from(String::from("1.0")),
+            LuaVal::from(LuaTable::new(HashMap::new())),
+        ]
+    }
+
+    #[test]
+    fn eq_for_ints() {
+        let types = get_eq_types();
+        let int = LuaVal::from(1);
+        assert_eq!(int, types[0]);
+        assert_eq!(int, types[1]);
+        assert_ne!(int, types[2]);
+        assert_ne!(int, types[3]);
+        let int = LuaVal::from(2);
+        for i in 0..4 {
+            assert_ne!(int, types[i]);
+        }
+    }
+
+    #[test]
+    fn eq_for_floats() {
+        let types = get_eq_types();
+        let float = LuaVal::from(1.0);
+        assert_eq!(float, types[0]);
+        assert_eq!(float, types[1]);
+        assert_ne!(float, types[2]);
+        assert_ne!(float, types[3]);
+        let float = LuaVal::from(2.0);
+        for i in 0..4 {
+            assert_ne!(float, types[i]);
+        }
+    }
+
+    #[test]
+    fn eq_for_tables() {
+        let types = get_eq_types();
+        let table = LuaVal::from(LuaTable::new(HashMap::new()));
+        assert_eq!(table, table);
+        for i in 0..4 {
+            assert_ne!(table, types[i]);
+        }
+    }
+
+    #[test]
+    fn eq_for_strings() {
+        let types = get_eq_types();
+        let string = LuaVal::from(String::from("1.0"));
+        assert_ne!(string, types[0]);
+        assert_ne!(string, types[1]);
+        assert_eq!(string, types[2]);
+        assert_ne!(string, types[3]);
+        let string = LuaVal::from(String::from("2.0"));
+        for i in 0..4 {
+            assert_ne!(string, types[i]);
+        }
+    }
 }