[Beam] Fix codegen issues and enable 9 more tests (#4359)

Author: dbrattli

src/Fable.Transforms/Beam/Fable2Beam.fs

@@ -58,6 +58,7 @@ let private isClassType (com: IBeamCompiler) (entityRef: EntityRef) =
             && not entity.IsFSharpModule
             && not entity.IsInterface
             && not entity.IsFSharpExceptionDeclaration
+            && not entity.IsValueType
         | None -> false
     | _ -> false
 
@@ -332,9 +333,24 @@ let rec transformExpr (com: IBeamCompiler) (ctx: Context) (expr: Expr) : Beam.Er
             ]
 
     | Delegate(args, body, _name, _tags) ->
+        // Deduplicate Erlang variable names in arg patterns.
+        // After uncurrying, inner lambda params that shadow outer ones appear at
+        // the same level. In Erlang, fun(X, X) -> requires both args to be equal,
+        // so we replace earlier duplicates with _ (anonymous/unused pattern).
+        let argNames =
+            args |> List.map (fun a -> capitalizeFirst a.Name |> sanitizeErlangVar)
+
         let argPats =
-            args
-            |> List.map (fun a -> Beam.PVar(capitalizeFirst a.Name |> sanitizeErlangVar))
+            let lastIndex = System.Collections.Generic.Dictionary<string, int>()
+            argNames |> List.iteri (fun i name -> lastIndex.[name] <- i)
+
+            argNames
+            |> List.mapi (fun i name ->
+                if lastIndex.[name] = i then
+                    Beam.PVar(name)
+                else
+                    Beam.PVar("_")
+            )
 
         let ctx' =
             { ctx with LocalVars = args |> List.fold (fun s a -> s.Add(a.Name)) ctx.LocalVars }
@@ -2228,6 +2244,41 @@ and transformClassDeclaration
                 // F# exception construction goes through NewRecord, not ClassDecl constructor.
                 // No need to generate a constructor function here.
                 []
+            elif ent.IsValueType then
+                // Struct/value type: return a plain map (not a ref) using sanitizeFieldName keys
+                // to match the record-style FieldGet path.
+                let ctorCtx =
+                    { ctx with
+                        LocalVars = ctorArgs |> List.fold (fun (s: Set<string>) a -> s.Add(a.Name)) ctx.LocalVars
+                    }
+
+                let mapEntries =
+                    fields
+                    |> List.map (fun (name, value) ->
+                        let erlValue = transformExpr com ctorCtx value
+                        atomLit (sanitizeFieldName name), erlValue
+                    )
+
+                let body = [ Beam.ErlExpr.Map mapEntries ]
+
+                let ctorFuncName = sanitizeErlangName cons.Name
+                com.RegisterConstructorName ent.FullName ctorFuncName
+
+                let funcDef: Beam.ErlFunctionDef =
+                    {
+                        Name = Beam.Atom ctorFuncName
+                        Arity = argPatterns.Length
+                        Clauses =
+                            [
+                                {
+                                    Patterns = argPatterns
+                                    Guard = []
+                                    Body = body
+                                }
+                            ]
+                    }
+
+                [ Beam.ErlForm.Function funcDef ]
             else
                 // Regular class: object = make_ref(), state in process dict
                 let ctorCtx =

src/Fable.Transforms/Beam/Replacements.fs

@@ -250,7 +250,7 @@ let private operators
             | Decimal -> Helper.LibCall(com, "fable_decimal", "to_string", _t, [ arg ], ?loc = r) |> Some
             | Float16
             | Float32
-            | Float64 -> emitExpr r _t [ arg ] "float_to_binary($0)" |> Some
+            | Float64 -> Helper.LibCall(com, "fable_convert", "to_string", _t, [ arg ], ?loc = r) |> Some
             | _ -> emitExpr r _t [ arg ] "integer_to_binary($0)" |> Some
         | Type.Boolean -> emitExpr r _t [ arg ] "atom_to_binary($0)" |> Some
         | _ -> Helper.LibCall(com, "fable_convert", "to_string", _t, [ arg ], ?loc = r) |> Some
@@ -323,19 +323,8 @@ let private operators
     | "op_PipeLeft2", [ f; x; y ] -> CurriedApply(f, [ x; y ], _t, r) |> Some
     | "op_PipeRight3", [ x; y; z; f ]
     | "op_PipeLeft3", [ f; x; y; z ] -> CurriedApply(f, [ x; y; z ], _t, r) |> Some
-    | "op_ComposeRight", [ f1; f2 ] ->
-        // fun x -> f2(f1(x))
-        let ident = makeTypedIdent _t "x"
-        let identExpr = IdentExpr ident
-        let innerCall = CurriedApply(f1, [ identExpr ], _t, None)
-        let outerCall = CurriedApply(f2, [ innerCall ], _t, None)
-        Lambda(ident, outerCall, None) |> Some
-    | "op_ComposeLeft", [ f2; f1 ] ->
-        let ident = makeTypedIdent _t "x"
-        let identExpr = IdentExpr ident
-        let innerCall = CurriedApply(f1, [ identExpr ], _t, None)
-        let outerCall = CurriedApply(f2, [ innerCall ], _t, None)
-        Lambda(ident, outerCall, None) |> Some
+    | "op_ComposeRight", [ f1; f2 ] -> compose com ctx r _t f1 f2 |> Some
+    | "op_ComposeLeft", [ f2; f1 ] -> compose com ctx r _t f1 f2 |> Some
     // Not (boolean negation)
     | "Not", [ operand ] -> makeUnOp r _t operand UnaryNot |> Some
     // Tuples
@@ -468,7 +457,7 @@ let private languagePrimitives
         let cmp = compare com r left right
         makeBinOp r Boolean cmp (makeIntConst 0) BinaryGreaterOrEqual |> Some
     | ("PhysicalEquality" | "PhysicalEqualityIntrinsic"), [ left; right ] ->
-        makeBinOp r Boolean left right BinaryEqual |> Some
+        emitExpr r Boolean [ left; right ] "$0 =:= $1" |> Some
     | ("GenericHash" | "GenericHashIntrinsic"), [ arg ] ->
         Helper.LibCall(com, "fable_comparison", "hash", t, [ arg ], ?loc = r) |> Some
     | ("PhysicalHash" | "PhysicalHashIntrinsic"), [ arg ] ->
@@ -590,7 +579,9 @@ let private objects
                 |> Some
             | Float16
             | Float32
-            | Float64 -> emitExpr r t [ thisObj ] "float_to_binary($0)" |> Some
+            | Float64 ->
+                Helper.LibCall(com, "fable_convert", "to_string", t, [ thisObj ], ?loc = r)
+                |> Some
             | _ -> emitExpr r t [ thisObj ] "integer_to_binary($0)" |> Some
         | Type.Boolean -> emitExpr r t [ thisObj ] "atom_to_binary($0)" |> Some
         | Type.String -> Some thisObj
@@ -1209,7 +1200,7 @@ let private conversions
             | Decimal -> Helper.LibCall(com, "fable_decimal", "to_string", t, [ arg ], ?loc = r) |> Some
             | Float16
             | Float32
-            | Float64 -> emitExpr r t [ arg ] "float_to_binary($0)" |> Some
+            | Float64 -> Helper.LibCall(com, "fable_convert", "to_string", t, [ arg ], ?loc = r) |> Some
             | _ -> emitExpr r t [ arg ] "integer_to_binary($0)" |> Some
         | Type.Boolean -> emitExpr r t [ arg ] "atom_to_binary($0)" |> Some
         | _ -> Helper.LibCall(com, "fable_convert", "to_string", t, [ arg ], ?loc = r) |> Some
@@ -1249,7 +1240,7 @@ let private numericTypes
             | Decimal -> Helper.LibCall(com, "fable_decimal", "to_string", t, [ c ], ?loc = r) |> Some
             | Float16
             | Float32
-            | Float64 -> emitExpr r t [ c ] "float_to_binary($0)" |> Some
+            | Float64 -> Helper.LibCall(com, "fable_convert", "to_string", t, [ c ], ?loc = r) |> Some
             | _ -> emitExpr r t [ c ] "integer_to_binary($0)" |> Some
         | _ -> None
     | "ToString", Some c, [ fmt ] ->

src/fable-library-beam/fable_string.erl

@@ -393,12 +393,10 @@ split_count_loop(Str, Seps, Count, Acc) ->
 to_string(V) when is_binary(V) -> V;
 to_string(V) when is_integer(V) -> integer_to_binary(V);
 to_string(V) when is_float(V) ->
-    %% Match Erlang float_to_binary default but trim trailing zeros
-    S = float_to_binary(V, [{decimals, 10}, compact]),
-    %% Ensure at least one decimal: "42" -> "42.0"
-    case binary:match(S, <<".">>) of
-        nomatch -> <<S/binary, ".0">>;
-        _ -> S
+    %% Match .NET ToString() "G" format: whole-number floats produce "2" not "2.0"
+    case V == trunc(V) of
+        true -> integer_to_binary(trunc(V));
+        false -> float_to_binary(V, [{decimals, 10}, compact])
     end;
 to_string(V) when is_atom(V) -> atom_to_binary(V, utf8);
 to_string(V) when is_boolean(V) ->
@@ -735,7 +733,12 @@ format_raw(Type, Prec, Value) when Type =:= $g; Type =:= $G ->
             trim_trailing_zeros(S)
     end;
 format_raw($x, _Prec, Value) ->
-    iolist_to_binary(io_lib:format("~.16b", [trunc(Value)]));
+    V = trunc(Value),
+    Masked = if V < 0, abs(V) > 16#FFFFFFFF -> V band 16#FFFFFFFFFFFFFFFF;
+                V < 0 -> V band 16#FFFFFFFF;
+                true -> V
+             end,
+    iolist_to_binary(io_lib:format("~.16b", [Masked]));
 format_raw($X, _Prec, Value) ->
     S = format_raw($x, _Prec, Value),
     string:uppercase(S);

tests/Beam/ApplicativeTests.fs

@@ -1351,13 +1351,11 @@ let ``test Partial active patterns can return bool`` () =
 
 // --- Arity record tests ---
 
-// TODO: Uncurrying naming collision — generates fun(X, X) -> which in Erlang
-// means both args must be equal (pattern matching), not two separate parameters.
-// [<Fact>]
-// let ``test Arity is checked also when constructing records`` () =
-//     let f i j = (i * 2) + (j * 3)
-//     let r = { arity2 = fun x -> f x >> fun y -> sprintf "foo%i" y }
-//     r.arity2 4 5 |> equal "foo23"
+[<Fact>]
+let ``test Arity is checked also when constructing records`` () =
+    let f i j = (i * 2) + (j * 3)
+    let r = { arity2 = fun x -> f x >> fun y -> sprintf "foo%i" y }
+    r.arity2 4 5 |> equal "foo23"
 
 // --- Module/Class values returning lambdas ---
 

tests/Beam/ComparisonTests.fs

@@ -677,16 +677,14 @@ let ``test isNull with objects works`` () =
     let s2: String = "hello"
     isNull s2 |> equal false
 
-// TODO: PhysicalEquality on ResizeArray (ref) uses fable_comparison:compare instead of =:=
-// because BinaryEqual on array/ref types gets structural comparison
-// [<Fact>]
-// let ``test PhysicalEquality works`` () =
-//     let r1 = ResizeArray([1; 2])
-//     let r2 = ResizeArray([1; 2])
-//     let r3 = r1
-//     LanguagePrimitives.PhysicalEquality r1 r2 |> equal false
-//     LanguagePrimitives.PhysicalEquality r2 r2 |> equal true
-//     LanguagePrimitives.PhysicalEquality r3 r1 |> equal true
+[<Fact>]
+let ``test PhysicalEquality works`` () =
+    let r1 = ResizeArray([1; 2])
+    let r2 = ResizeArray([1; 2])
+    let r3 = r1
+    LanguagePrimitives.PhysicalEquality r1 r2 |> equal false
+    LanguagePrimitives.PhysicalEquality r2 r2 |> equal true
+    LanguagePrimitives.PhysicalEquality r3 r1 |> equal true
 
 // --- Raw Erlang reference comparison tests ---
 // These test that fable_comparison correctly handles Erlang references

tests/Beam/DictionaryTests.fs

@@ -214,13 +214,12 @@ let ``test Dictionary KeyValuePattern works`` () =
         total <- y + total
     equal 385. total
 
-// TODO: IDictionary created via dict — indexer access goes through IDictionary which expects dict ref
-// [<Fact>]
-// let ``test Interface IDictionary creation works`` () =
-//     let dic =
-//         dict
-//         <| seq { for i in 1. .. 10. -> i.ToString(), i * i }
-//     equal 4. dic.["2"]
+[<Fact>]
+let ``test Interface IDictionary creation works`` () =
+    let dic =
+        dict
+        <| seq { for i in 1. .. 10. -> i.ToString(), i * i }
+    equal 4. dic.["2"]
 
 [<Fact>]
 let ``test Dictionary creation from IDictionary works`` () =

tests/Beam/SeqExpressionTests.fs

@@ -46,15 +46,14 @@ let ``test for in seq expressions works`` () =
     seq { for x in 1 .. 10 do yield x }
     |> Seq.length |> equal 10
 
-// TODO: while in seq generates (fable_seq:delay(...))(ok) double-evaluation — badfun error
-// [<Fact>]
-// let ``test while in seq expressions works`` () =
-//     let mutable n = 0
-//     seq {
-//         while n < 10 do
-//             n <- n + 1
-//             yield n
-//     } |> Seq.sum |> equal 55
+[<Fact>]
+let ``test while in seq expressions works`` () =
+    let mutable n = 0
+    seq {
+        while n < 10 do
+            n <- n + 1
+            yield n
+    } |> Seq.sum |> equal 55
 
 [<Fact>]
 let ``test recursive seq expressions work`` () =
@@ -69,18 +68,17 @@ let ``test recursive seq expressions work`` () =
     let t = Node(Node(Leaf, 1, Leaf), 2, Node(Leaf, 3, Leaf))
     traverse t |> Seq.sum |> equal 9
 
-// TODO: try/finally in seq generates (fable_seq:delay(...))(ok) double-evaluation + util:exception not available
-// [<Fact>]
-// let ``test try finally in seq expressions works`` () =
-//     let mutable n = 0
-//     try seq {
-//         try
-//             raise (exn "My message")
-//         finally
-//             n <- n + 1
-//         } |> Seq.iter ignore
-//     with _ -> ()
-//     equal 1 n
+[<Fact>]
+let ``test try finally in seq expressions works`` () =
+    let mutable n = 0
+    try seq {
+        try
+            raise (exn "My message")
+        finally
+            n <- n + 1
+        } |> Seq.iter ignore
+    with _ -> ()
+    equal 1 n
 
 [<Fact>]
 let ``test array expressions work`` () =

tests/Beam/StringTests.fs

@@ -517,9 +517,9 @@ let ``test sprintf "%X" works`` () =
     sprintf "255: %x" 255 |> equal "255: ff"
     sprintf "4095L: %X" 4095L |> equal "4095L: FFF"
 
-// TODO: Negative hex formatting requires two's complement masking which isn't implemented
-// sprintf "-255: %X" -255 |> equal "-255: FFFFFF01"
-// sprintf "-4095L: %X" -4095L |> equal "-4095L: FFFFFFFFFFFFF001"
+    sprintf "-255: %X" -255 |> equal "-255: FFFFFF01"
+    // TODO: int64 negative hex needs 64-bit mask but Erlang can't distinguish int32 from int64 at runtime
+    // sprintf "-4095L: %X" -4095L |> equal "-4095L: FFFFFFFFFFFFF001"
 
 [<Fact>]
 let ``test sprintf integers with sign and padding works`` () =

tests/Beam/TailCallTests.fs

@@ -57,6 +57,17 @@ module Functions =
         | 0 -> x
         | _ -> iterate f (n - 1) (f x)
 
+    let recWithFinally () =
+        let mutable log = ""
+        let rec test n =
+          try
+            log <- log + string "abcde".[n]
+            if n < 4 then test (n+1)
+          finally
+            log <- log + string "ABCDE".[n]
+        test 0
+        log
+
 open Functions
 
 module Issue3301 =
@@ -195,12 +206,6 @@ let ``test Mutually recursive functions can be partially optimized`` () =
     |> Seq.concat |> Seq.map string |> String.concat ""
     |> equal "56"
 
-// TODO: recWithFinally generates syntax error in Erlang (try/finally in recursive function)
-// [<Fact>]
-// let ``test Recursive functions containing finally work`` () =
-//     recWithFinally () |> equal "abcdeEDCBA"
-
-// TODO: recWithUse generates syntax error in Erlang (object expression IDisposable)
-// [<Fact>]
-// let ``test Recursive functions containing use work`` () =
-//     recWithUse () |> equal "abcdeEDCBA"
+[<Fact>]
+let ``test Recursive functions containing finally work`` () =
+    recWithFinally () |> equal "abcdeEDCBA"

tests/Beam/TypeTests.fs

@@ -558,14 +558,13 @@ let areEqual (x: obj) (y: obj) = x = y
 // and typeof comparison require runtime type information not available in Erlang.
 // TypeCast is erased, so :?> only works for simple casts (e.g., obj to concrete type via box/unbox).
 
-// TODO: Struct types with val fields generate badmap on undefined
-// [<Fact>]
-// let ``test Value Type records work`` () =
-//     let foo1 = ValueType<_>("foo")
-//     let foo2 = ValueType<_>("foo")
-//     foo1.Value |> equal "foo"
-//     foo1.value |> equal "foo"
-//     foo1 = foo2 |> equal true
+[<Fact>]
+let ``test Value Type records work`` () =
+    let foo1 = ValueType<_>("foo")
+    let foo2 = ValueType<_>("foo")
+    foo1.Value |> equal "foo"
+    foo1.value |> equal "foo"
+    foo1 = foo2 |> equal true
 
 [<Fact>]
 let ``test Value Type unions work`` () =
@@ -579,21 +578,19 @@ let ``test Value Type tuples work`` () =
     let tu2 = struct ("a", "b")
     tu1 = tu2 |> equal true
 
-// TODO: Struct types with val fields generate badmap on undefined
-// [<Fact>]
-// let ``test Value Types work`` () =
-//     let bar1 = ValueType1("bar")
-//     let bar2 = ValueType1("bar")
-//     bar1.Value |> equal "bar"
-//     bar1 = bar2 |> equal true
+[<Fact>]
+let ``test Value Types work`` () =
+    let bar1 = ValueType1("bar")
+    let bar2 = ValueType1("bar")
+    bar1.Value |> equal "bar"
+    bar1 = bar2 |> equal true
 
-// TODO: Struct types with val fields generate badmap on undefined
-// [<Fact>]
-// let ``test Other Value Types work`` () =
-//     let test2 = ValueType2(3, 4)
-//     test2.Value |> equal 7
-//     let p = Point2D(2.)
-//     p.Y |> equal 2.
+[<Fact>]
+let ``test Other Value Types work`` () =
+    let test2 = ValueType2(3, 4)
+    test2.Value |> equal 7
+    let p = Point2D(2.)
+    p.Y |> equal 2.
 
 [<Fact>]
 let ``test Custom F# exceptions work`` () =