fix: [Rust] Enable more tests

Author: ncave

src/Fable.Transforms/Rust/Fable2Rust.fs

@@ -4095,16 +4095,14 @@ module Util =
 
         let makeImportBound com ctx moduleName typeName =
             let importName = getLibraryImportName com ctx moduleName typeName
-            let objectBound = mkTypeTraitGenericBound [ importName ] None
-            objectBound
+            mkTypeTraitGenericBound [ importName ] None
 
         let makeRawBound id = makeGenBound [ rawIdent id ] []
 
         let makeOpBound op =
             // makes ops type bound, e.g. T: Add(Output=T)
             let ty = mkGenericPathTy [ argName ] None
             let genArgsOpt = mkConstraintArgs [] [ "Output", ty ]
-
             mkTypeTraitGenericBound ("core" :: "ops" :: op :: []) genArgsOpt
 
         let makeConstraint c =
@@ -4117,7 +4115,7 @@ module Util =
                 | Operators.division, true -> [ makeOpBound "Div" ]
                 | Operators.modulus, true -> [ makeOpBound "Rem" ]
                 | Operators.unaryNegation, true -> [ makeOpBound "Neg" ]
-                | Operators.divideByInt, true -> [ makeOpBound "Div"; makeGenBound [ rawIdent "From" ] [ "i32" ] ]
+                | Operators.divideByInt, true -> [ makeImportBound com ctx "Native" "DivideByInt" ]
                 | "get_Zero", true -> [ makeRawBound "Default" ]
                 | _ -> []
             | Fable.Constraint.CoercesTo(targetType) ->
@@ -5043,6 +5041,7 @@ module Util =
                 Operators.multiply, ("bin_op", "Mul", "mul") // The multiplication operator *.
                 Operators.division, ("bin_op", "Div", "div") // The division operator /.
                 Operators.modulus, ("bin_op", "Rem", "rem") // The remainder operator %.
+                Operators.divideByInt, ("div_int_op", "DivideByInt", "divide_by_int") // The integer division operator DivideByInt.
 
                 Operators.bitwiseAnd, ("bin_op", "BitAnd", "bitand") // The bitwise AND operator &.
                 Operators.bitwiseOr, ("bin_op", "BitOr", "bitor") // The bitwise OR operator |.
@@ -5099,6 +5098,55 @@ module Util =
             )
         )
 
+    let makeDefaultTraitImpls
+        com
+        ctx
+        (ent: Fable.Entity)
+        entName
+        genArgs
+        (members: (Fable.MemberDecl * Fable.MemberFunctionOrValue) list)
+        =
+        // For value types that are not defaultable (e.g. unions),
+        // generate a Default impl delegating to the static Zero member:
+        //
+        // impl<...> core::default::Default for EntName<...> {
+        //     fn default() -> Self { Self::get_Zero() }
+        // }
+        let needsExplicitDefault =
+            ent.IsValueType && not (ent |> isDefaultableEntity com Set.empty)
+
+        if not needsExplicitDefault then
+            []
+        else
+            members
+            |> List.tryPick (fun (decl, memb) ->
+                if
+                    not memb.IsInstance
+                    && (memb.CompiledName = "get_Zero"
+                        || memb.CompiledName = "Zero"
+                        || decl.Name = "get_Zero")
+                then
+                    let zeroMemberName = Fable.Naming.splitLast decl.Name
+                    let bodyExpr = makeCall [ "Self"; zeroMemberName ] None []
+                    let fnBody = bodyExpr |> mkExprBlock |> Some
+
+                    let fnDecl =
+                        let output = mkGenericPathTy [ "Self" ] None |> mkFnRetTy
+                        mkFnDecl [] output
+
+                    let fnKind = mkFnKind DEFAULT_FN_HEADER fnDecl NO_GENERICS fnBody
+                    let fnItem = mkFnAssocItem [] "default" fnKind
+
+                    let path =
+                        mkGenericPath ("core" :: "default" :: (rawIdent "Default") :: []) None None
+
+                    let ofTrait = mkTraitRef path |> Some
+                    [ fnItem ] |> makeTraitImpl com ctx entName genArgs ofTrait |> Some
+                else
+                    None
+            )
+            |> Option.toList
+
     let withCurrentScope ctx (usedNames: Set<string>) f =
         let ctx =
             { ctx with UsedNames = { ctx.UsedNames with CurrentDeclarationScope = HashSet usedNames } }
@@ -5224,6 +5272,9 @@ module Util =
             (baseTypeOpt, "&self." + baseName)
             ||> makeDerefTraitImpls com ctx entName genArgs
 
+        let defaultTraitImpls =
+            nonInterfaceMembers |> makeDefaultTraitImpls com ctx ent entName genArgs
+
         let displayTraitImpls =
             let hasToString =
                 nonInterfaceMembers |> List.exists (fun (d, m) -> m.CompiledName = "ToString")
@@ -5283,8 +5334,9 @@ module Util =
                 |> makeInterfaceTraitImpls com ctx entName genParams ifcEntRef ifcGenArgs
             )
 
-        derefTraitImpls
-        @ nonInterfaceImpls
+        nonInterfaceImpls
+        @ derefTraitImpls
+        @ defaultTraitImpls
         @ displayTraitImpls
         @ operatorTraitImpls
         @ refEqualityTraitImpls

src/Fable.Transforms/Rust/Replacements.fs

@@ -383,7 +383,8 @@ let applyOp (com: ICompiler) (ctx: Context) r t opName (args: Expr list) =
             | _ -> binOp BinaryMinus left right
         | Operators.multiply, [ left; right ] -> binOp BinaryMultiply left right
         | Operators.division, [ left; right ] -> binOp BinaryDivide left right
-        | Operators.divideByInt, [ left; right ] -> binOp BinaryDivide left (TypeCast(right, t))
+        | Operators.divideByInt, [ left; right ] ->
+            Helper.LibCall(com, "Native", "divideByInt", t, [ left; right ], argTypes, ?loc = r)
         | Operators.modulus, [ left; right ] -> binOp BinaryModulus left right
         | Operators.leftShift, [ left; right ] -> binOp BinaryShiftLeft left right |> truncateUnsigned // See #1530
         | Operators.rightShift, [ left; right ] ->
@@ -950,8 +951,14 @@ let operators (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisArg: Expr o
             |> Some
     | "DefaultAsyncBuilder", _ -> makeImportLib com t "singleton" "AsyncBuilder" |> Some
     // Erased operators.
-    // KeyValuePair is already compiled as a tuple
-    | ("KeyValuePattern" | "Identity" | "Box" | "Unbox" | "ToEnum"), [ arg ] -> TypeCast(arg, t) |> Some
+    // Rust compiles KeyValuePair as a struct tuple, but the KeyValue active pattern expects a regular tuple.
+    | "KeyValuePattern", [ arg ] ->
+        match arg.Type with
+        | Builtin(BclKeyValuePair(keyType, valueType)) ->
+            makeTuple r false [ Get(arg, TupleIndex 0, keyType, r); Get(arg, TupleIndex 1, valueType, r) ]
+            |> Some
+        | _ -> TypeCast(arg, t) |> Some
+    | ("Identity" | "Box" | "Unbox" | "ToEnum"), [ arg ] -> TypeCast(arg, t) |> Some
     // Cast to unit to make sure nothing is returned when wrapped in a lambda, see #1360
     | "Ignore", _ -> Value(UnitConstant, r) |> Some
     // Number and String conversions
@@ -3123,6 +3130,8 @@ let guids
     | "Parse", None, [ ExprType String ] -> Helper.LibCall(com, "Guid", "parse", t, args, ?loc = r) |> Some
     | "TryParse", None, [ ExprType String; _ ] -> Helper.LibCall(com, "Guid", "tryParse", t, args, ?loc = r) |> Some
     | "ToByteArray", Some x, [] -> Helper.LibCall(com, "Guid", "toByteArray", t, [ x ], ?loc = r) |> Some
+    | "ToString", Some x, [ ExprType String ] ->
+        Helper.LibCall(com, "Guid", "toStringFormat", t, [ x ] @ args, ?loc = r) |> Some
     | "ToString", Some x, [] -> toString com ctx r [ x ] |> Some
     // TODO: other methods and overrides
     | _ -> None

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

@@ -2,15 +2,15 @@
 pub mod BigInt_ {
     use crate::Decimal_::{decimal, truncate};
     use crate::NativeArray_::{array_from, Array};
-    use crate::Native_::{compare, getHashCode, Hashable, Lrc, MutCell, ToString, Vec};
+    use crate::Native_::{compare, getHashCode, DivideByInt, Hashable, Lrc, MutCell, ToString, Vec};
     use crate::String_::{string, toString as toString_1};
 
     use num_bigint::*;
     use num_integer::*;
     use num_traits::*;
 
-    #[repr(transparent)]
     #[derive(Clone, Debug, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
+    #[repr(transparent)]
     pub struct bigint(Lrc<BigInt>);
 
     impl From<BigInt> for bigint {
@@ -33,6 +33,13 @@ pub mod BigInt_ {
         }
     }
 
+    impl DivideByInt for bigint {
+        #[inline]
+        fn divide_by_int(self, rhs: i32) -> Self {
+            self / fromInt32(rhs)
+        }
+    }
+
     impl Hashable for bigint {
         #[inline]
         fn getHashCode(&self) -> i32 {

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

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

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

@@ -456,20 +456,28 @@ pub mod DateTime_ {
         }
 
         pub fn toString(&self, format: string) -> string {
+            if matches!(format.as_str(), "o" | "O") {
+                let cdt = self.to_cdt_fixed();
+                let frac = (self.ticks() % ticks_per_second).abs();
+                let date = cdt.format("%Y-%m-%dT%H:%M:%S");
+                let s = match self.kind {
+                    DateTimeKind::Utc => format!("{}.{:07}Z", date, frac),
+                    DateTimeKind::Local => format!("{}.{:07}{}", date, frac, cdt.format("%:z")),
+                    DateTimeKind::Unspecified => format!("{}.{:07}", date, frac),
+                };
+                return fromString(s);
+            }
+
             let fmt = match format.as_str() {
                 "" => "%m/%d/%Y %H:%M:%S".to_string(),
                 "g" => "%m/%d/%Y %H:%M".to_string(),
                 "G" => "%m/%d/%Y %H:%M:%S".to_string(),
-                "o" | "O" => match self.kind {
-                    DateTimeKind::Utc => "%Y-%m-%dT%H:%M:%S%.fZ".to_string(),
-                    DateTimeKind::Local => "%Y-%m-%dT%H:%M:%S%.f%:z".to_string(),
-                    DateTimeKind::Unspecified => "%Y-%m-%dT%H:%M:%S%.f".to_string(),
-                },
                 //TODO: support more formats, custom formats, etc.
                 _ => format
                     .replace("yyyy", "%Y")
                     .replace("MM", "%m")
                     .replace("dd", "%d")
+                    .replace("HH", "%H")
                     .replace("hh", "%H")
                     .replace("mm", "%M")
                     .replace("ss", "%S")

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

@@ -16,8 +16,8 @@ pub mod DateTimeOffset_ {
     };
     use core::ops::{Add, Sub};
 
-    #[repr(transparent)]
     #[derive(Clone, Copy, Debug)]
+    #[repr(transparent)]
     pub struct DateTimeOffset(CDateTime<FixedOffset>);
 
     impl core::fmt::Display for DateTimeOffset {

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

@@ -1,6 +1,6 @@
 #[cfg(feature = "decimal")]
 pub mod Decimal_ {
-    use crate::Native_::{compare, getHashCode, Hashable, Lrc, MutCell, Vec};
+    use crate::Native_::{compare, getHashCode, DivideByInt, 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 DivideByInt for decimal {
+        #[inline]
+        fn divide_by_int(self, rhs: i32) -> Self {
+            self / Decimal::from_i32(rhs).unwrap()
+        }
+    }
+
     impl Hashable for decimal {
         #[inline]
         fn getHashCode(&self) -> i32 {

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

@@ -3,7 +3,7 @@ pub mod Guid_ {
     use crate::DateTimeOffset_::DateTimeOffset;
     use crate::NativeArray_::{new_array, Array};
     use crate::Native_::{compare, getHashCode, Hashable, MutCell};
-    use crate::String_::{string, toString};
+    use crate::String_::{fromString, string, toString};
     use uuid::{NoContext, Timestamp, Uuid};
 
     #[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
@@ -62,6 +62,36 @@ pub mod Guid_ {
         new_array(&x.0.to_bytes_le())
     }
 
+    pub fn toStringFormat(x: Guid, format: string) -> string {
+        match format.as_str() {
+            "" | "D" | "d" => fromString(x.0.hyphenated().to_string()),
+            "N" | "n" => fromString(x.0.simple().to_string()),
+            "B" | "b" => fromString(format!("{{{}}}", x.0.hyphenated())),
+            "P" | "p" => fromString(format!("({})", x.0.hyphenated())),
+            "X" | "x" => {
+                let bytes = x.0.as_bytes();
+                let data1 = u32::from_be_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
+                let data2 = u16::from_be_bytes([bytes[4], bytes[5]]);
+                let data3 = u16::from_be_bytes([bytes[6], bytes[7]]);
+                fromString(format!(
+                    "{{0x{:08x},0x{:04x},0x{:04x},{{0x{:02x},0x{:02x},0x{:02x},0x{:02x},0x{:02x},0x{:02x},0x{:02x},0x{:02x}}}}}",
+                    data1,
+                    data2,
+                    data3,
+                    bytes[8],
+                    bytes[9],
+                    bytes[10],
+                    bytes[11],
+                    bytes[12],
+                    bytes[13],
+                    bytes[14],
+                    bytes[15]
+                ))
+            }
+            _ => panic!("Format specifier was invalid."),
+        }
+    }
+
     pub fn create_version7() -> Guid {
         let dto = DateTimeOffset::utcNow();
         create_version7_with_timestamp(dto)

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

@@ -318,6 +318,10 @@ pub mod Native_ {
         Default::default()
     }
 
+    pub fn divideByInt<T: DivideByInt>(x: T, y: i32) -> T {
+        x.divide_by_int(y)
+    }
+
     pub fn min<T: PartialOrd>(x: T, y: T) -> T {
         if x < y {
             x
@@ -594,6 +598,25 @@ pub mod Native_ {
     // Operator traits
     // -----------------------------------------------------------
 
+    pub trait DivideByInt: Sized {
+        fn divide_by_int(self, rhs: i32) -> Self;
+    }
+
+    macro_rules! divide_by_int_impl {
+        ($($t:ty),* $(,)?) => {
+            $(
+                impl DivideByInt for $t {
+                    #[inline]
+                    fn divide_by_int(self, rhs: i32) -> Self {
+                        self / (rhs as $t)
+                    }
+                }
+            )*
+        };
+    }
+
+    divide_by_int_impl!(i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, usize, f32, f64);
+
     #[macro_export]
     macro_rules! un_op {
         ($op_trait:ident, $op_fn:ident, $op:ident, $obj:ty, $($args:ty),*) => {
@@ -620,7 +643,20 @@ pub mod Native_ {
         };
     }
 
+    #[macro_export]
+    macro_rules! div_int_op {
+        ($op_trait:ident, $op_fn:ident, $op:ident, $obj:ty, $rhs:ty, $($args:ty,)*) => {
+            impl<$($args),*> $crate::Native_::DivideByInt for $obj {
+                #[inline]
+                fn divide_by_int(self, rhs: i32) -> Self {
+                    <$obj>::$op(self, rhs)
+                }
+            }
+        };
+    }
+
     pub use crate::bin_op;
+    pub use crate::div_int_op;
     pub use crate::un_op;
 
     // -----------------------------------------------------------

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

@@ -18,8 +18,8 @@ pub mod String_ {
     mod HeapString {
         use crate::Native_::{Lrc, NullableRef, String};
 
-        #[repr(transparent)]
         #[derive(Clone)]
+        #[repr(transparent)]
         pub struct LrcStr(Option<Lrc<str>>);
 
         pub type string = LrcStr;