fix: [Rust] Update hashing tests

Author: ncave

src/Fable.Transforms/Rust/Fable2Rust.fs

@@ -4956,7 +4956,7 @@ module Util =
 
     let makeRefEqualityTraitImpls com ctx entName genArgs =
         // For F# class types without structural equality, use pointer-based
-        // PartialEq, Eq, and Hash so they can be used as HashSet/HashMap keys
+        // PartialEq, Eq, Hash, and Hashable so they can be used as HashSet/HashMap keys
         // with reference (pointer) equality semantics, matching .NET behavior.
         // expected output:
         // impl PartialEq for {self_ty} {
@@ -4968,6 +4968,9 @@ module Util =
         //         core::hash::Hash::hash(&(self as *const Self as usize), state)
         //     }
         // }
+        // impl Native_::Hashable for {self_ty} {
+        //     fn getHashCode(&self) -> i32 { Native_::referenceHash(self) }
+        // }
 
         let eqFnItem =
             let bodyStmt = "core::ptr::eq(self, other)" |> mkEmitExprStmt
@@ -5009,10 +5012,24 @@ module Util =
             let fnKind = mkFnKind DEFAULT_FN_HEADER fnDecl generics fnBody
             mkFnAssocItem [] "hash" fnKind
 
+        let getHashCodeFnItem =
+            let referenceHashName = getLibraryImportName com ctx "Native" "referenceHash"
+            let bodyStmt = $"{referenceHashName}(self)" |> mkEmitExprStmt
+            let fnBody = [ bodyStmt ] |> mkBlock |> Some
+
+            let fnDecl =
+                let inputs = [ mkImplSelfParam false false ]
+                let output = mkGenericPathTy [ "i32" ] None |> mkFnRetTy
+                mkFnDecl inputs output
+
+            let fnKind = mkFnKind DEFAULT_FN_HEADER fnDecl NO_GENERICS fnBody
+            mkFnAssocItem [ mkAttr "inline" [] ] "getHashCode" fnKind
+
         [
             makeImpl ("core" :: "cmp" :: rawIdent "PartialEq" :: []) [ eqFnItem ]
             makeImpl ("core" :: "cmp" :: rawIdent "Eq" :: []) []
             makeImpl ("core" :: "hash" :: "Hash" :: []) [ hashFnItem ]
+            makeImpl (getLibraryImportName com ctx "Native" "Hashable" |> splitNameParts) [ getHashCodeFnItem ]
         ]
 
     let op_impl_map =

src/fable-library-rust/src/BigInt.rs

@@ -2,7 +2,7 @@
 pub mod BigInt_ {
     use crate::Decimal_::{decimal, truncate};
     use crate::NativeArray_::{array_from, Array};
-    use crate::Native_::{compare, Lrc, MutCell, ToString, Vec};
+    use crate::Native_::{compare, getHashCode, Hashable, Lrc, MutCell, ToString, Vec};
     use crate::String_::{string, toString as toString_1};
 
     use num_bigint::*;
@@ -33,6 +33,13 @@ pub mod BigInt_ {
         }
     }
 
+    impl Hashable for bigint {
+        #[inline]
+        fn getHashCode(&self) -> i32 {
+            getHashCode(self)
+        }
+    }
+
     macro_rules! un_op {
         ($op_trait:ident, $op_fn:ident, $op:tt) => {
             impl core::ops::$op_trait for bigint {

src/fable-library-rust/src/DateOnly.rs

@@ -2,7 +2,7 @@
 pub mod DateOnly_ {
     use crate::{
         DateTime_::{ticks_to_duration, DateTime, DateTimeKind},
-        Native_::{compare, MutCell, ToString},
+        Native_::{compare, getHashCode, Hashable, MutCell, ToString},
         String_::{fromString, string},
         TimeOnly_::TimeOnly,
         TimeSpan_::ticks_per_day,
@@ -19,6 +19,13 @@ pub mod DateOnly_ {
         }
     }
 
+    impl Hashable for DateOnly {
+        #[inline]
+        fn getHashCode(&self) -> i32 {
+            getHashCode(self)
+        }
+    }
+
     pub fn compareTo(x: DateOnly, y: DateOnly) -> i32 {
         compare(&x, &y)
     }

src/fable-library-rust/src/DateTime.rs

@@ -3,7 +3,7 @@ pub mod DateTime_ {
     use crate::{
         DateOnly_::DateOnly,
         DateTimeOffset_::DateTimeOffset,
-        Native_::{compare, MutCell, ToString},
+        Native_::{compare, getHashCode, Hashable, MutCell, ToString},
         String_::{fromString, string},
         TimeOnly_::TimeOnly,
         TimeSpan_::{nanoseconds_per_tick, ticks_per_second, TimeSpan},
@@ -45,6 +45,13 @@ pub mod DateTime_ {
         }
     }
 
+    impl Hashable for DateTime {
+        #[inline]
+        fn getHashCode(&self) -> i32 {
+            getHashCode(&self.ticks())
+        }
+    }
+
     pub fn compareTo(x: DateTime, y: DateTime) -> i32 {
         compare(&x.ticks(), &y.ticks())
     }

src/fable-library-rust/src/DateTimeOffset.rs

@@ -3,7 +3,7 @@ pub mod DateTimeOffset_ {
     use crate::{
         DateOnly_::DateOnly,
         DateTime_::{duration_to_ticks, ticks_to_duration, DateTime, DateTimeKind},
-        Native_::{compare, MutCell, ToString},
+        Native_::{compare, getHashCode, Hashable, MutCell, ToString},
         String_::{fromString, string},
         TimeOnly_::TimeOnly,
         TimeSpan_::{
@@ -38,6 +38,13 @@ pub mod DateTimeOffset_ {
         }
     }
 
+    impl Hashable for DateTimeOffset {
+        #[inline]
+        fn getHashCode(&self) -> i32 {
+            getHashCode(&self.utcTicks())
+        }
+    }
+
     pub fn compareTo(x: DateTimeOffset, y: DateTimeOffset) -> i32 {
         compare(&x.utcDateTime(), &y.utcDateTime())
     }

src/fable-library-rust/src/Decimal.rs

@@ -1,6 +1,6 @@
 #[cfg(feature = "decimal")]
 pub mod Decimal_ {
-    use crate::Native_::{compare, Lrc, MutCell, Vec};
+    use crate::Native_::{compare, getHashCode, Hashable, Lrc, MutCell, Vec};
     use crate::NativeArray_::{new_array, Array};
     use crate::String_::{string, toString as toString_1};
     use core::cmp::Ordering;
@@ -14,6 +14,13 @@ pub mod Decimal_ {
     pub const MaxValue: decimal = Decimal::MAX;
     pub const MinValue: decimal = Decimal::MIN;
 
+    impl Hashable for decimal {
+        #[inline]
+        fn getHashCode(&self) -> i32 {
+            getHashCode(self)
+        }
+    }
+
     pub fn equals(x: decimal, y: decimal) -> bool { x.eq(&y) }
     pub fn compareTo(x: decimal, y: decimal) -> i32 { compare(&x, &y) }
 

src/fable-library-rust/src/Guid.rs

@@ -2,7 +2,7 @@
 pub mod Guid_ {
     use crate::DateTimeOffset_::DateTimeOffset;
     use crate::NativeArray_::{new_array, Array};
-    use crate::Native_::{compare, MutCell};
+    use crate::Native_::{compare, getHashCode, Hashable, MutCell};
     use crate::String_::{string, toString};
     use uuid::{NoContext, Timestamp, Uuid};
 
@@ -17,6 +17,14 @@ pub mod Guid_ {
         }
     }
 
+    impl Hashable for Guid {
+        #[inline]
+        fn getHashCode(&self) -> i32 {
+            let bytes = toByteArray(*self);
+            getHashCode(&bytes.as_slice())
+        }
+    }
+
     pub fn compareTo(x: Guid, y: Guid) -> i32 {
         compare(&x, &y)
     }

src/fable-library-rust/src/Interop.rs

@@ -75,7 +75,7 @@ pub mod ListExt {
 }
 
 pub mod SetExt {
-    use crate::Native_::{Func2, Hashable, NullableRef, Vec, make_compare, seq_to_iter};
+    use crate::Native_::{Func2, Hashable, NullableRef, Vec, combineHashCodes, make_compare, seq_to_iter};
     use crate::Set_::{Set, add, compareTo, empty, equals, isEmpty, toSeq};
     use core::cmp::Ordering;
     use core::hash::{Hash, Hasher};
@@ -113,6 +113,17 @@ pub mod SetExt {
 
     impl<T: Clone + Hashable + PartialOrd> Eq for Set<T> {}
 
+    impl<T: Clone + Hashable + PartialOrd> Hashable for Set<T> {
+        fn getHashCode(&self) -> i32 {
+            let s = toSeq(self.clone());
+            let mut res = 0_i32;
+            for value in seq_to_iter(s) {
+                res = combineHashCodes(res, value.getHashCode());
+            }
+            res
+        }
+    }
+
     impl<T: Clone + Hashable + PartialOrd + Hash> Hash for Set<T> {
         fn hash<H: Hasher>(&self, state: &mut H) {
             let s = toSeq(self.clone());
@@ -171,7 +182,7 @@ pub mod SetExt {
 
 pub mod MapExt {
     use crate::Map_::{Map, add, compareTo, empty, equals, isEmpty, iterate, toSeq};
-    use crate::Native_::{Func2, Hashable, NullableRef, Vec, make_compare, seq_to_iter};
+    use crate::Native_::{Func2, Hashable, NullableRef, Vec, combineHashCodes, make_compare, seq_to_iter};
     use core::cmp::Ordering;
     use core::hash::{Hash, Hasher};
 
@@ -208,6 +219,19 @@ pub mod MapExt {
 
     impl<K: Clone + Hashable + PartialOrd, V: Clone + Hashable + PartialOrd> Eq for Map<K, V> {}
 
+    impl<K: Clone + Hashable + PartialOrd, V: Clone + Hashable + PartialOrd> Hashable for Map<K, V> {
+        fn getHashCode(&self) -> i32 {
+            let s = toSeq(self.clone());
+            let mut res = 0_i32;
+            for kvp in seq_to_iter(s) {
+                let (key, value) = kvp.as_ref();
+                res = combineHashCodes(res, key.getHashCode());
+                res = combineHashCodes(res, value.getHashCode());
+            }
+            res
+        }
+    }
+
     impl<K: Clone + Hashable + PartialOrd + Hash, V: Clone + Hash> Hash for Map<K, V> {
         fn hash<H: Hasher>(&self, state: &mut H) {
             let s = toSeq(self.clone());

src/fable-library-rust/src/LrcPtr.rs

@@ -1,4 +1,4 @@
-use crate::Native_::{Any, Lrc, NullableRef};
+use crate::Native_::{Any, Hashable, Lrc, NullableRef};
 use core::cmp::Ordering;
 use core::hash::{Hash, Hasher};
 use core::ops::*;
@@ -48,6 +48,13 @@ impl<T: ?Sized> Clone for LrcPtr<T> {
     }
 }
 
+impl<T: Hashable + ?Sized> Hashable for LrcPtr<T> {
+    #[inline]
+    fn getHashCode(&self) -> i32 {
+        self.0.as_ref().map_or(0, |value| value.getHashCode())
+    }
+}
+
 impl<T: ?Sized> Deref for LrcPtr<T> {
     type Target = Lrc<T>;