fix: [Rust] Fix float hashing

Author: ncave

src/Fable.Transforms/Rust/Fable2Rust.fs

@@ -579,7 +579,6 @@ module TypeInfo =
         | Fable.Unit
         | Fable.Measure _
         | Fable.MetaType
-        | Fable.Number((Float32 | Float64), _)
         | Fable.LambdaType _
         | Fable.DelegateType _ -> false
         | _ -> isTypeOfType com isHashableType isHashableEntity entNames typ
@@ -2323,7 +2322,7 @@ module Util =
                     exprField :: exprFields
                 | _ -> exprFields
 
-            let attrs = [ mkAttr "derive" (makeDerivedFrom com ent) ]
+            let attrs = [ mkAttr "derive" (makeDerivedFrom com ctx ent) ]
             let generics = makeGenerics com ctx genArgs
             let genParams = FSharp2Fable.Util.getGenParamTypes genArgs
 
@@ -4143,9 +4142,9 @@ module Util =
             | Fable.Constraint.IsReferenceType -> [ makeImportBound com ctx "Native" "NullableRef" ]
             | Fable.Constraint.HasDefaultConstructor -> []
             | Fable.Constraint.HasAllowsRefStruct -> []
-            | Fable.Constraint.HasComparison -> [ makeRawBound "PartialOrd" ]
-            | Fable.Constraint.HasEquality ->
-                [ makeGenBound ("core" :: "hash" :: "Hash" :: []) []; makeRawBound "PartialEq" ]
+            | Fable.Constraint.HasComparison ->
+                [ makeImportBound com ctx "Native" "Hashable"; makeRawBound "PartialOrd" ]
+            | Fable.Constraint.HasEquality -> [ makeImportBound com ctx "Native" "Hashable"; makeRawBound "PartialEq" ]
             | Fable.Constraint.IsUnmanaged -> []
             | Fable.Constraint.IsDelegate _ -> []
             | Fable.Constraint.IsEnum _ -> []
@@ -4532,7 +4531,7 @@ module Util =
         let fnItem = mkFnAssocItem attrs name fnKind
         fnItem
 
-    let makeDerivedFrom com (ent: Fable.Entity) =
+    let makeDerivedFrom com ctx (ent: Fable.Entity) =
         let isCopyable = false //ent |> isCopyableEntity com Set.empty
         let isCloneable = true //ent |> isCloneableEntity com Set.empty
         let isPrintable = ent |> isPrintableEntity com Set.empty
@@ -4552,7 +4551,7 @@ module Util =
                 if isDefaultable then
                     rawIdent "Default"
                 if isHashable then
-                    rawIdent "Hash"
+                    getLibraryImportName com ctx "Native" "Hashable"
                 if isEquatable then
                     rawIdent "PartialEq"
                 if isComparable then
@@ -4601,7 +4600,7 @@ module Util =
             )
 
         let attrs = transformAttributes com ctx ent.Attributes decl.XmlDoc
-        let attrs = attrs @ [ mkAttr "derive" (makeDerivedFrom com ent) ]
+        let attrs = attrs @ [ mkAttr "derive" (makeDerivedFrom com ctx ent) ]
         let enumItem = mkEnumItem attrs entName variants generics
         enumItem
 
@@ -4641,7 +4640,7 @@ module Util =
         let fields = List.append fields phantomFields
 
         let attrs = transformAttributes com ctx ent.Attributes decl.XmlDoc
-        let attrs = attrs @ [ mkAttr "derive" (makeDerivedFrom com ent) ]
+        let attrs = attrs @ [ mkAttr "derive" (makeDerivedFrom com ctx ent) ]
         let structItem = mkStructItem attrs entName fields generics
         structItem
 

src/Fable.Transforms/Rust/Replacements.fs

@@ -445,13 +445,13 @@ let referenceHash (com: ICompiler) ctx r (arg: Expr) =
     | Boolean
     | Char
     | String
-    | Number _ -> Helper.LibCall(com, "Native", "getHashCode", Int32.Number, [ arg ], ?loc = r)
+    | Number _ -> Helper.InstanceCall(arg, "getHashCode", Int32.Number, [], [], [], ?loc = r)
     | _ -> Helper.LibCall(com, "Native", "referenceHash", Int32.Number, [ makeRef arg ], ?loc = r)
 
 let getHashCode (com: ICompiler) ctx r (arg: Expr) =
     match arg.Type with
     | HasReferenceEquality com _ -> referenceHash com ctx r arg
-    | _ -> Helper.LibCall(com, "Native", "getHashCode", Int32.Number, [ arg ], ?loc = r)
+    | _ -> Helper.InstanceCall(arg, "getHashCode", Int32.Number, [], [], [], ?loc = r)
 
 let objectHash (com: ICompiler) ctx r (arg: Expr) =
     match arg.Type with

src/fable-library-rust/Cargo.toml

@@ -23,13 +23,14 @@ default = ["bigint", "datetime", "decimal", "enum_func", "enum_string", "guid",
 chrono = { version = "0.4", optional = true }
 futures = { version = "0.3", features = ["executor", "thread-pool"], default-features = false, optional = true }
 futures-timer = { version = "3.0", optional = true }
+hashable = { version = "0.1", path = "vendored/hashable" }
 hashbrown = { version = "0.17", optional = true }
 num-bigint = { version = "0.4", optional = true }
 num-integer = { version = "0.1", optional = true }
 num-traits = { version = "0.2", optional = true }
 rand = { version = "0.10", features = ["std_rng"], default-features = false, optional = true }
 regex = { version = "1.12", optional = true }
-rust_decimal = { version = "1.41", features = ["maths"], default-features = false, optional = true }
+rust_decimal = { version = "1.42", features = ["maths"], default-features = false, optional = true }
 startup = { version = "0.1", path = "vendored/startup", optional = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

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

@@ -10,7 +10,7 @@ pub mod DateOnly_ {
     use chrono::{DateTime as CDateTime, Datelike, Months, NaiveDate, NaiveTime, ParseResult};
 
     #[repr(transparent)]
-    #[derive(Clone, Copy, PartialEq, PartialOrd, Debug)]
+    #[derive(Clone, Copy, Debug, Hash, PartialEq, PartialOrd)]
     pub struct DateOnly(NaiveDate);
 
     impl core::fmt::Display for DateOnly {

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

@@ -14,7 +14,6 @@ pub mod Decimal_ {
     pub const MaxValue: decimal = Decimal::MAX;
     pub const MinValue: decimal = Decimal::MIN;
 
-    // pub fn getHashCode(x: decimal) = x.GetHashCode()
     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/HashMap.rs

@@ -11,7 +11,7 @@ pub mod HashMap_ {
 
     use crate::NativeArray_::{array_from, Array};
     use crate::Native_::{default_eq_comparer, seq_to_iter};
-    use crate::Native_::{HashKey, LrcPtr, MutCell, Seq, Vec};
+    use crate::Native_::{HashKey, Hashable, LrcPtr, MutCell, Seq, Vec};
     use crate::System::Collections::Generic::IEqualityComparer_1;
 
     use core::fmt::{Debug, Display, Formatter, Result};
@@ -71,14 +71,14 @@ pub mod HashMap_ {
 
     pub fn new_empty<K, V: Clone>() -> HashMap<K, V>
     where
-        K: Clone + Hash + PartialEq + 'static,
+        K: Clone + Hashable + PartialEq + 'static,
     {
         make_hash_map(collections::HashMap::new(), default_eq_comparer::<K>())
     }
 
     pub fn new_with_capacity<K, V: Clone>(capacity: i32) -> HashMap<K, V>
     where
-        K: Clone + Hash + PartialEq + 'static,
+        K: Clone + Hashable + PartialEq + 'static,
     {
         make_hash_map(
             collections::HashMap::with_capacity(capacity as usize),
@@ -104,7 +104,7 @@ pub mod HashMap_ {
 
     pub fn new_from_enumerable<K, V: Clone + 'static>(seq: Seq<(K, V)>) -> HashMap<K, V>
     where
-        K: Clone + Hash + PartialEq + 'static,
+        K: Clone + Hashable + PartialEq + 'static,
     {
         from_iter(seq_to_iter(seq), default_eq_comparer::<K>())
     }
@@ -129,7 +129,7 @@ pub mod HashMap_ {
 
     pub fn new_from_tuple_array<K, V: Clone>(a: Array<LrcPtr<(K, V)>>) -> HashMap<K, V>
     where
-        K: Clone + Hash + PartialEq + 'static,
+        K: Clone + Hashable + PartialEq + 'static,
     {
         let it = a.iter().map(|tup| tup.as_ref().clone());
         from_iter(it, default_eq_comparer::<K>())

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

@@ -12,7 +12,7 @@ pub mod HashSet_ {
     use crate::Global_::SR::indexOutOfBounds;
     use crate::NativeArray_::{array_from, Array};
     use crate::Native_::{default_eq_comparer, seq_to_iter};
-    use crate::Native_::{HashKey, LrcPtr, MutCell, Seq, Vec};
+    use crate::Native_::{HashKey, Hashable, LrcPtr, MutCell, Seq, Vec};
     use crate::System::Collections::Generic::IEqualityComparer_1;
 
     use core::fmt::{Debug, Display, Formatter, Result};
@@ -78,14 +78,14 @@ pub mod HashSet_ {
 
     pub fn new_empty<T>() -> HashSet<T>
     where
-        T: Clone + Hash + PartialEq + 'static,
+        T: Clone + Hashable + PartialEq + 'static,
     {
         make_hash_set(collections::HashSet::new(), default_eq_comparer::<T>())
     }
 
     pub fn new_with_capacity<T>(capacity: i32) -> HashSet<T>
     where
-        T: Clone + Hash + PartialEq + 'static,
+        T: Clone + Hashable + PartialEq + 'static,
     {
         make_hash_set(
             collections::HashSet::with_capacity(capacity as usize),
@@ -109,7 +109,7 @@ pub mod HashSet_ {
 
     pub fn new_from_enumerable<T>(seq: Seq<T>) -> HashSet<T>
     where
-        T: Clone + Hash + PartialEq + 'static,
+        T: Clone + Hashable + PartialEq + 'static,
     {
         from_iter(seq_to_iter(seq), default_eq_comparer::<T>())
     }
@@ -204,7 +204,7 @@ pub mod HashSet_ {
         if destIndex < 0 || count < 0 || count > set_len || destIndex + count > dest_len {
             panic!("{}", indexOutOfBounds());
         }
-        let mut dest = dest.get_mut();
+        let dest = dest.get_mut();
         let it = to_iter(&set).take(count as usize);
         for (offset, item) in it.enumerate() {
             dest[destIndex as usize + offset] = item;

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

@@ -1,7 +1,7 @@
 pub mod ListExt {
     // use core::ops::Deref;
-    use crate::List_::{cons, empty, isEmpty, reverse, List};
-    use crate::Native_::{seq_to_iter, NullableRef, Vec};
+    use crate::List_::{List, cons, empty, isEmpty, reverse};
+    use crate::Native_::{NullableRef, Vec, seq_to_iter};
     use crate::Seq_::ofList;
 
     impl<T: Clone> List<T> {
@@ -75,12 +75,12 @@ pub mod ListExt {
 }
 
 pub mod SetExt {
-    use crate::Native_::{make_compare, seq_to_iter, Func2, NullableRef, Vec};
-    use crate::Set_::{add, compareTo, empty, equals, isEmpty, toSeq, Set};
+    use crate::Native_::{Func2, Hashable, NullableRef, Vec, make_compare, seq_to_iter};
+    use crate::Set_::{Set, add, compareTo, empty, equals, isEmpty, toSeq};
     use core::cmp::Ordering;
     use core::hash::{Hash, Hasher};
 
-    impl<T: Clone + PartialOrd> Set<T> {
+    impl<T: Clone + Hashable + PartialOrd> Set<T> {
         //todo - non-consuming iter by ref
         // pub fn iter<'a>(&self) -> impl Iterator<Item = & 'a T> {
         //     let s = toSeq(self.clone());
@@ -105,34 +105,34 @@ pub mod SetExt {
         }
     }
 
-    impl<T: Clone + PartialOrd> PartialEq for Set<T> {
+    impl<T: Clone + Hashable + PartialOrd> PartialEq for Set<T> {
         fn eq(&self, other: &Self) -> bool {
             equals(self.clone(), other.clone())
         }
     }
 
-    impl<T: Clone + PartialOrd> Eq for Set<T> {}
+    impl<T: Clone + Hashable + PartialOrd> Eq for Set<T> {}
 
-    impl<T: Clone + PartialOrd + Hash> Hash for Set<T> {
+    impl<T: Clone + Hashable + PartialOrd + Hash> Hash for Set<T> {
         fn hash<H: Hasher>(&self, state: &mut H) {
             let s = toSeq(self.clone());
             seq_to_iter(s).for_each(|x| x.hash(state))
         }
     }
 
-    impl<T: Clone + PartialOrd> PartialOrd for Set<T> {
+    impl<T: Clone + Hashable + PartialOrd> PartialOrd for Set<T> {
         fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
             Some(make_compare(Func2::from(compareTo))(self, other))
         }
     }
 
-    impl<T: Clone + PartialOrd> Ord for Set<T> {
+    impl<T: Clone + Hashable + PartialOrd> Ord for Set<T> {
         fn cmp(&self, other: &Self) -> Ordering {
             make_compare(Func2::from(compareTo))(self, other)
         }
     }
 
-    impl<T: Clone + PartialOrd> From<Vec<T>> for Set<T> {
+    impl<T: Clone + Hashable + PartialOrd> From<Vec<T>> for Set<T> {
         fn from(vec: Vec<T>) -> Self {
             let mut set = empty();
             for v in vec.iter() {
@@ -142,7 +142,7 @@ pub mod SetExt {
         }
     }
 
-    impl<T: Clone + PartialOrd> From<&Vec<T>> for Set<T> {
+    impl<T: Clone + Hashable + PartialOrd> From<&Vec<T>> for Set<T> {
         fn from(vec: &Vec<T>) -> Self {
             let mut set = empty();
             for v in vec.iter() {
@@ -152,7 +152,7 @@ pub mod SetExt {
         }
     }
 
-    impl<T: Clone + PartialOrd> FromIterator<T> for Set<T> {
+    impl<T: Clone + Hashable + PartialOrd> FromIterator<T> for Set<T> {
         fn from_iter<U: IntoIterator<Item = T>>(iter: U) -> Self {
             let mut set = empty();
             for v in iter.into_iter() {
@@ -162,20 +162,20 @@ pub mod SetExt {
         }
     }
 
-    impl<T: Clone + PartialOrd> Into<Vec<T>> for Set<T> {
+    impl<T: Clone + Hashable + PartialOrd> Into<Vec<T>> for Set<T> {
         fn into(self) -> Vec<T> {
             self.into_iter().collect()
         }
     }
 }
 
 pub mod MapExt {
-    use crate::Map_::{add, compareTo, empty, equals, isEmpty, iterate, toSeq, Map};
-    use crate::Native_::{make_compare, seq_to_iter, Func2, NullableRef, Vec};
+    use crate::Map_::{Map, add, compareTo, empty, equals, isEmpty, iterate, toSeq};
+    use crate::Native_::{Func2, Hashable, NullableRef, Vec, make_compare, seq_to_iter};
     use core::cmp::Ordering;
     use core::hash::{Hash, Hasher};
 
-    impl<K: Clone + PartialOrd, V: Clone> Map<K, V> {
+    impl<K: Clone + Hashable + PartialOrd, V: Clone> Map<K, V> {
         //todo - non-consuming iter by ref
         // pub fn iter<'a>(&self) -> impl Iterator<Item = (& 'a K, & 'a V)> {
         //     let s = toSeq(self.clone());
@@ -188,7 +188,7 @@ pub mod MapExt {
         }
     }
 
-    impl<K: Clone + PartialOrd, V: Clone> NullableRef for Map<K, V> {
+    impl<K: Clone + Hashable + PartialOrd, V: Clone> NullableRef for Map<K, V> {
         #[inline]
         fn null() -> Self {
             empty()
@@ -200,34 +200,34 @@ pub mod MapExt {
         }
     }
 
-    impl<K: Clone + PartialOrd, V: Clone + PartialOrd> PartialEq for Map<K, V> {
+    impl<K: Clone + Hashable + PartialOrd, V: Clone + Hashable + PartialOrd> PartialEq for Map<K, V> {
         fn eq(&self, other: &Self) -> bool {
             equals(self.clone(), other.clone())
         }
     }
 
-    impl<K: Clone + PartialOrd, V: Clone + PartialOrd> Eq for Map<K, V> {}
+    impl<K: Clone + Hashable + PartialOrd, V: Clone + Hashable + PartialOrd> Eq for Map<K, V> {}
 
-    impl<K: Clone + PartialOrd + Hash, V: Clone + Hash> Hash for Map<K, V> {
+    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());
             seq_to_iter(s).for_each(|kvp| kvp.hash(state))
         }
     }
 
-    impl<K: Clone + PartialOrd, V: Clone + PartialOrd> PartialOrd for Map<K, V> {
+    impl<K: Clone + Hashable + PartialOrd, V: Clone + Hashable + PartialOrd> PartialOrd for Map<K, V> {
         fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
             Some(make_compare(Func2::from(compareTo))(self, other))
         }
     }
 
-    impl<K: Clone + PartialOrd, V: Clone + PartialOrd> Ord for Map<K, V> {
+    impl<K: Clone + Hashable + PartialOrd, V: Clone + Hashable + PartialOrd> Ord for Map<K, V> {
         fn cmp(&self, other: &Self) -> Ordering {
             make_compare(Func2::from(compareTo))(self, other)
         }
     }
 
-    impl<K: Clone + PartialOrd, V: Clone> From<&Vec<(K, V)>> for Map<K, V> {
+    impl<K: Clone + Hashable + PartialOrd, V: Clone> From<&Vec<(K, V)>> for Map<K, V> {
         fn from(vec: &Vec<(K, V)>) -> Self {
             let mut map: Map<K, V> = empty();
             for (i, (k, v)) in vec.iter().rev().enumerate() {
@@ -237,7 +237,7 @@ pub mod MapExt {
         }
     }
 
-    impl<K: Clone + PartialOrd, V: Clone> FromIterator<(K, V)> for Map<K, V> {
+    impl<K: Clone + Hashable + PartialOrd, V: Clone> FromIterator<(K, V)> for Map<K, V> {
         fn from_iter<U: IntoIterator<Item = (K, V)>>(iter: U) -> Self {
             let mut map: Map<K, V> = empty();
             for (k, v) in iter.into_iter() {
@@ -247,7 +247,7 @@ pub mod MapExt {
         }
     }
 
-    impl<K: Clone + PartialOrd, V: Clone> Into<Vec<(K, V)>> for Map<K, V> {
+    impl<K: Clone + Hashable + PartialOrd, V: Clone> Into<Vec<(K, V)>> for Map<K, V> {
         fn into(self) -> Vec<(K, V)> {
             self.into_iter().collect()
         }