[Rust] Fixed Dictionary constructor from IEnumerable (#3788)

Author: ncave

src/Fable.Cli/CHANGELOG.md

@@ -12,6 +12,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * [JS/TS] Fixed `DateTime.Add` for `DateTimeKind.Unspecified` (by @ncave)
 * [Rust] Fixed deprecated `NaiveDateTime` usage in `DateTime` (by @ncave)
 * [Rust] Fixed generic interface implementation types (by @ncave)
+* [Rust] Fixed Dictionary constructor from IEnumerable (by @ncave)
+* [Rust] Fixed Seq.cast support for arrays and lists (by @ncave)
 
 ### Added
 

src/Fable.Transforms/Rust/Fable2Rust.fs

@@ -1200,6 +1200,7 @@ module Util =
     let (|IEnumerable|_|) =
         function
         | Replacements.Util.IsEntity (Types.ienumerableGeneric) (_, [ genArg ]) -> Some(genArg)
+        | Replacements.Util.IsEntity (Types.ienumerable) _ -> Some(Fable.Any)
         | _ -> None
 
     let isUnitArg (ident: Fable.Ident) =
@@ -1450,6 +1451,12 @@ module Util =
             let ar = makeLibCall com ctx None "HashMap" "entries" [ expr ]
             makeLibCall com ctx None "Seq" "ofArray" [ ar ]
 
+        // boxing value types or wrapped types
+        | t, Fable.Any when isValueType com t || isWrappedType com t -> expr |> boxValue com ctx
+
+        // unboxing value types or wrapped types
+        | Fable.Any, t when isValueType com t || isWrappedType com t -> expr |> unboxValue com ctx t
+
         // casts to generic param
         | _, Fable.GenericParam(name, _isMeasure, _constraints) -> makeCall (name :: "from" :: []) None [ expr ] // e.g. T::from(value)
 
@@ -1462,12 +1469,6 @@ module Util =
         // casts from interface to interface
         | _, t when isInterface com t -> expr |> makeClone |> mkCastExpr ty //TODO: not working, implement
 
-        // boxing value types or wrapped types
-        | t, Fable.Any when isValueType com t || isWrappedType com t -> expr |> boxValue com ctx
-
-        // unboxing value types or wrapped types
-        | Fable.Any, t when isValueType com t || isWrappedType com t -> expr |> unboxValue com ctx t
-
         // // casts to System.Object
         // | _, Fable.Any ->
         //     let ty = transformType com ctx toType

src/Fable.Transforms/Rust/Replacements.fs

@@ -944,7 +944,7 @@ let operators (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisArg: Expr o
     | "ToString", _ -> toString com ctx r args |> Some
     | "CreateSequence", [ xs ] -> toSeq com t xs |> Some
     | ("CreateDictionary" | "CreateReadOnlyDictionary"), [ arg ] ->
-        Helper.LibCall(com, "HashMap", "new_from_array", t, [ toArray com t arg ])
+        Helper.LibCall(com, "HashMap", "new_from_tup_array", t, [ toArray com t arg ])
         |> Some
     | "CreateSet", _ -> (genArg com ctx r 0 i.GenericArgs) |> makeSet com ctx r t args |> Some
     // Ranges
@@ -1571,7 +1571,6 @@ let formattableString
 
 let seqModule (com: ICompiler) (ctx: Context) r (t: Type) (i: CallInfo) (thisArg: Expr option) (args: Expr list) =
     match i.CompiledName, args with
-    | "Cast", [ MaybeCasted(arg) ] -> Some arg // Erase
     // | "ToArray", [arg] ->
     //     Helper.LibCall(com, "Array", "ofSeq", t, args, i.SignatureArgTypes, ?loc=r) |> Some
     | "ToList", [ arg ] ->
@@ -2300,7 +2299,7 @@ let dictionaries (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisArg: Exp
         | [ ExprType(Number _) ] -> Helper.LibCall(com, "HashMap", "new_with_capacity", t, args) |> Some
         | [ ExprType(IEnumerable) ] ->
             let a = Helper.LibCall(com, "Seq", "toArray", t, args)
-            Helper.LibCall(com, "HashMap", "new_from_array", t, [ a ]) |> Some
+            Helper.LibCall(com, "HashMap", "new_from_kvp_array", t, [ a ]) |> Some
         // match i.SignatureArgTypes, args with
         // | ([]|[Number _]), _ ->
         //     makeDictionary com ctx r t (makeArray Any []) |> Some

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

@@ -43,8 +43,13 @@ pub mod HashMap_ {
         )))
     }
 
-    pub fn new_from_array<K: Eq + Hash + Clone, V: Clone>(a: Array<LrcPtr<(K, V)>>) -> HashMap<K, V> {
-        let it = a.iter().map(|pair| pair.as_ref().clone());
+    pub fn new_from_tup_array<K: Eq + Hash + Clone, V: Clone>(a: Array<LrcPtr<(K, V)>>) -> HashMap<K, V> {
+        let it = a.iter().map(|tup| tup.as_ref().clone());
+        HashMap(mkRefMut(collections::HashMap::from_iter(it)))
+    }
+
+    pub fn new_from_kvp_array<K: Eq + Hash + Clone, V: Clone>(a: Array<(K, V)>) -> HashMap<K, V> {
+        let it = a.iter().map(|kvp| kvp.clone());
         HashMap(mkRefMut(collections::HashMap::from_iter(it)))
     }
 

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

@@ -186,19 +186,19 @@ pub mod Native_ {
     // Interface casting
     // -----------------------------------------------------------
 
-    #[cfg(feature = "lrc_ptr")]
+    #[cfg(not(feature = "lrc_ptr"))]
     #[macro_export]
     macro_rules! interface_cast {
         ($value:expr, $ifc:ty,) => {
-            LrcPtr::from((*$value).clone() as $ifc)
+            ($value as $ifc)
         };
     }
 
-    #[cfg(not(feature = "lrc_ptr"))]
+    #[cfg(feature = "lrc_ptr")]
     #[macro_export]
     macro_rules! interface_cast {
         ($value:expr, $ifc:ty,) => {
-            ($value as $ifc)
+            LrcPtr::from((*$value).clone() as $ifc)
         };
     }
 
@@ -261,11 +261,18 @@ pub mod Native_ {
         LrcPtr::new(MutCell::from(x))
     }
 
+    #[cfg(not(feature = "lrc_ptr"))]
     #[inline]
     pub fn box_<T: 'static>(x: T) -> LrcPtr<dyn Any> {
         LrcPtr::new(x) as LrcPtr<dyn Any>
     }
 
+    #[cfg(feature = "lrc_ptr")]
+    #[inline]
+    pub fn box_<T: 'static>(x: T) -> LrcPtr<dyn Any> {
+        LrcPtr::from(Lrc::new(x) as Lrc<dyn Any>)
+    }
+
     #[inline]
     pub fn unbox<T: Clone + 'static>(o: &LrcPtr<dyn Any>) -> T {
         try_downcast::<_, T>(o).unwrap().clone()

src/fable-library-rust/src/Seq.fs

@@ -150,6 +150,15 @@ module Enumerable =
 
         fromFunction next
 
+    let cast (e: IEnumerator<obj>) : IEnumerator<'T> =
+        let next () =
+            if e.MoveNext() then
+                Some(unbox<'T> e.Current)
+            else
+                None
+
+        fromFunction next
+
     let concat (sources: 'T seq seq) : IEnumerator<'T> =
         let mutable outerOpt: IEnumerator<'T seq> option = None
         let mutable innerOpt: IEnumerator<'T> option = None
@@ -486,12 +495,11 @@ let append (xs: 'T seq) (ys: 'T seq) =
     // concat [| xs; ys |]
     mkSeq (fun () -> Enumerable.append xs ys)
 
-// let cast (xs: System.Collections.IEnumerable) =
-//     mkSeq (fun () ->
-//         checkNonNull "source" xs
-//         xs.GetEnumerator()
-//         |> Enumerable.cast
-//     )
+let cast (xs: obj seq) =
+    mkSeq (fun () ->
+        // checkNonNull "source" xs
+        xs.GetEnumerator() |> Enumerable.cast
+    )
 
 let choose (chooser: 'T -> 'U option) (xs: 'T seq) =
     generate

tests/Rust/tests/src/DictionaryTests.fs

@@ -29,11 +29,12 @@ let ``Dictionary ctor with capacity works`` () =
     let dict = Dictionary<int, int>(10)
     dict.Count |> equal 0
 
-// [<Fact>]
-// let ``Dictionary ctor from IEnumerable works`` () =
-//     let xs = seq { ("A", 1); ("B", 2); ("C", 3) }
-//     let dict = Dictionary(xs |> Seq.map KeyValuePair)
-//     dict.Count |> equal 3
+[<Fact>]
+let ``Dictionary ctor from IEnumerable works`` () =
+    let xs = seq { ("A", 1); ("B", 2); ("C", 3) }
+    // let dict = Dictionary(xs |> Seq.map KeyValuePair) //TODO:
+    let dict = Dictionary(xs |> Seq.map (fun (k, v) -> KeyValuePair(k, v)))
+    dict.Count |> equal 3
 
 [<Fact>]
 let ``IDictionary ctor works`` () =
@@ -114,13 +115,13 @@ let ``Dictionary indexer works`` () =
     dict["A"] |> equal 3
     dict["B"] |> equal 2
 
-// [<Fact>]
-// let ``Dictionary indexer works II`` () =
-//     let dict = Dictionary<string, obj>()
-//     dict["A"] <- "Hello"
-//     dict["B"] <- 2
-//     dict["B"].ToString()
-//     |> equal "2"
+[<Fact>]
+let ``Dictionary indexer works II`` () =
+    let dict = Dictionary<string, obj>()
+    dict["A"] <- "Hello"
+    dict["B"] <- 2
+    // dict["B"].ToString() |> equal "2" //TODO:
+    dict["B"] |> unbox<int> |> equal 2
 
 [<Fact>]
 let ``Dictionary.TryAdd works`` () =

tests/Rust/tests/src/RegexTests.fs

@@ -199,7 +199,10 @@ let ``Regex.Matches iteration with casting works`` () =
     let str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
     let ms = Regex.Matches(str, "[A-E]", RegexOptions.IgnoreCase)
     let count =
-        ms |> Seq.cast<Match> |> Seq.fold(fun acc m -> acc + m.Value.Length) 0
+        ms
+        // |> Seq.cast<Match> //TODO:
+        :> seq<Match>
+        |> Seq.fold(fun acc m -> acc + m.Value.Length) 0
     equal 10 count
 
 [<Fact>]
@@ -333,7 +336,8 @@ let ``Replacing with $0 works`` () = // See #1155
 [<Fact>]
 let ``Group values are correct and empty when not being matched`` () =
     Regex.Matches("\n\n\n", @"(?:([^\n\r]+)|\r\n|\n\r|\n|\r)")
-    |> Seq.cast<Match>
+    // |> Seq.cast<Match> //TODO:
+    :> seq<Match>
     |> Seq.map (fun m -> m.Groups[1].Value)
     |> Seq.forall (fun value -> value = "")
     |> equal true

tests/Rust/tests/src/SeqTests.fs

@@ -908,11 +908,11 @@ let ``Seq.cache works when enumerating partially`` () =
     loop (Seq.cache xs) [] |> equal (Some 99)
     loop xs [] |> equal (Some 99)
 
-// [<Fact>]
-// let ``Seq.cast works`` () =
-//     let xs = [box 1; box 2; box 3]
-//     let ys = Seq.cast<int> xs
-//     ys |> Seq.head |> equal 1
+[<Fact>]
+let ``Seq.cast works`` () =
+    let xs = [box 1; box 2; box 3]
+    let ys = Seq.cast<int> xs
+    ys |> Seq.toArray |> equal [|1; 2; 3|]
 
 [<Fact>]
 let ``Seq.countBy works`` () =