[Beam] Improve test coverage and fix runtime bugs (2022→2086) (#4347)

Author: dbrattli

src/Fable.Cli/CHANGELOG.md

@@ -9,7 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-* [Beam] Add Erlang/BEAM target (`--lang beam`). Compiles F# to `.erl` source files. 2010 tests passing. (by @dbrattli)
+* [Beam] Add Erlang/BEAM target (`--lang beam`). Compiles F# to `.erl` source files. 2086 tests passing. (by @dbrattli)
 
 ## 5.0.0-alpha.24 - 2026-02-13
 

src/Fable.Compiler/CHANGELOG.md

@@ -9,7 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-* [Beam] Add Erlang/BEAM compilation support: Fable2Beam transform, Beam Replacements, ErlangPrinter, and 31 runtime `.erl` modules (by @dbrattli)
+* [Beam] Add Erlang/BEAM compilation support: Fable2Beam transform, Beam Replacements, ErlangPrinter, and 31 runtime `.erl` modules. 2086 tests passing. (by @dbrattli)
 
 ## 5.0.0-alpha.23 - 2026-02-13
 

src/Fable.Transforms/Beam/FABLE-BEAM.md

@@ -118,7 +118,7 @@ Erlang modules implementing F# core types:
 | fable_comparison.erl | Comparison | compare/2 returning -1/0/1 | Done |
 | fable_char.erl | Char utilities | is_letter/digit/upper/lower/whitespace | Done |
 | fable_convert.erl | Type conversions | Robust to_float handling edge cases | Done |
-| fable_reflection.erl | Reflection helpers | Type info as Erlang maps | Done |
+| fable_reflection.erl | Reflection | Full FSharpType/FSharpValue support: TypeInfo as maps, record/union/tuple/function type tests, GetRecordFields/MakeRecord, GetUnionFields/MakeUnion, GetTupleFields/MakeTuple, PropertyInfo.GetValue | Done |
 | fable_result.erl | Result | {ok, V} or {error, E} | Done |
 | fable_set.erl | FSharpSet | ordsets (sorted lists), fold/map/filter/partition/union_many/intersect_many | Done |
 | fable_async_builder.erl | AsyncBuilder | CPS builder operations (bind, return, delay, etc.) | Done |
@@ -342,7 +342,7 @@ decision trees, and let/letrec bindings all produce correct Erlang output.
 2. Compiles tests to `.erl` via Fable (library files auto-copied to `fable_modules/fable-library-beam/`)
 3. Compiles library `.erl` files in `fable_modules/fable-library-beam/` with `erlc`
 4. Compiles test `.erl` files with `erlc -pa fable_modules/fable-library-beam`
-5. Runs an Erlang test runner (`erl_test_runner.erl`) with `-pa fable_modules/fable-library-beam` that discovers and executes all `test_`-prefixed functions (2022 Erlang tests pass)
+5. Runs an Erlang test runner (`erl_test_runner.erl`) with `-pa fable_modules/fable-library-beam` that discovers and executes all `test_`-prefixed functions (2077 Erlang tests pass)
 
 | Test File | Tests | Coverage |
 | --- | --- | --- |
@@ -375,12 +375,12 @@ decision trees, and let/letrec bindings all produce correct Erlang output.
 | UnionTypeTests.fs | 18 | Union construction, matching, structural equality, active patterns |
 | InteropTests.fs | 17 | Erlang interop, emitErl, Import attribute, module calls |
 | DictionaryTests.fs | 17 | Dictionary creation, Add, Count, indexer get/set, ContainsKey, ContainsValue, Remove, TryGetValue, Clear, dict function, integer keys, duplicate key throws, missing key throws, iteration, creation from existing dict |
-| AsyncTests.fs | 17 | Async return, let!/do!, return!, try-with, sleep, parallel, ignore, start immediate, cancellation |
+| AsyncTests.fs | 31 | Async return, let!/do!, return!, try-with, sleep, parallel, ignore, start immediate, while/for binding, exception handling, nested try/with, StartWithContinuations, Async.Catch, FromContinuations, deep recursion, nested failure propagation, try/finally, Async.Bind propagation, unit argument erasure, cancellation (CTS create/cancel, register, multiple registers, pre-cancelled token, auto-cancel, Dispose, custom exceptions) |
 | QueueTests.fs | 17 | Queue creation, Enqueue, Dequeue, Peek, TryDequeue, TryPeek, Contains, Clear, ToArray, throws |
 | TailCallTests.fs | 15 | Tail call optimization, recursive functions, mutual recursion (parseTokens/parseNum) |
 | TupleTests.fs | 15 | Tuple creation, destructuring, fst/snd, equality, nesting, struct tuples, map, comparison, Item1/Item2 |
 | LoopTests.fs | 12 | for loops, while loops, nested loops, mutable variables, for-in over list/array |
-| ReflectionTests.fs | 11 | Type info, FSharpType reflection |
+| ReflectionTests.fs | 35 | Type info, typedefof, GetGenericTypeDefinition, Type.Name/FullName/Namespace, FSharpType (IsTuple, IsRecord, IsUnion, IsFunction, GetTupleElements, GetFunctionElements, MakeTupleType, GetRecordFields, GetUnionCases), FSharpValue (GetRecordFields, MakeRecord, GetTupleFields, MakeTuple, GetTupleField, GetUnionFields, MakeUnion), PropertyInfo.GetValue, Result/Choice reflection, units of measure type info |
 | GuidTests.fs | 10 | Guid.NewGuid, Parse, ToString, Empty, equality, comparison |
 | ExceptionTests.fs | 10 | Custom exceptions, type discrimination, nested catch, field access, Message property |
 | StackTests.fs | 9 | Stack creation, Push, Pop, Peek, TryPop, TryPeek, Contains, ToArray, Clear |
@@ -395,7 +395,7 @@ decision trees, and let/letrec bindings all produce correct Erlang output.
 | MailboxProcessorTests.fs | 3 | MailboxProcessor post, postAndAsyncReply, postAndAsyncReply with falsy values |
 | SudokuTests.fs | 1 | Integration test: Sudoku solver using Seq, Array, ranges |
 | ObservableTests.fs | 12 | Observable.subscribe/add/choose/filter/map/merge/pairwise/partition/scan/split, IObservable.Subscribe, Disposing |
-| **Total** | **2022** | |
+| **Total** | **2077** | |
 
 ### Phase 3: Discriminated Unions & Records -- COMPLETE
 
@@ -582,7 +582,7 @@ for mutable state, `fable_async:from_continuations` for the receive/reply coordi
 ### Phase 10: Ecosystem
 
 - [ ] Build integration (`rebar3` or `mix` project generation)
-- [x] Test suite (`tests/Beam/` — 2022 Erlang tests passing, `./build.sh test beam`)
+- [x] Test suite (`tests/Beam/` — 2077 Erlang tests passing, `./build.sh test beam`)
 - [x] Erlang test runner (`tests/Beam/erl_test_runner.erl` — discovers and runs all `test_`-prefixed arity-1 functions)
 - [x] `erlc` compilation step in build pipeline (per-file with graceful failure)
 - [x] Quicktest setup (`src/quicktest-beam/`, `Fable.Build/Quicktest/Beam.fs`)
@@ -992,6 +992,21 @@ alone eliminates the single hardest piece of the Fable.Python runtime.
 - **Stopwatch**: Runtime `fable_stopwatch.erl` using `erlang:monotonic_time(microsecond)`.
   Supports `StartNew`, `Start`, `Stop`, `Reset`, `Restart`, `Elapsed`, `ElapsedMilliseconds`,
   `IsRunning`, `Frequency`, `GetTimestamp`.
+- **FSharp.Reflection**: Full runtime support via `fable_reflection.erl` + compile-time type
+  info generation in `Fable2Beam.Reflection.fs`. TypeInfo = Erlang map with `fullname`,
+  `generics`, and optional `fields` (records) or `cases` (unions). PropertyInfo/CaseInfo are
+  maps with `name`, `typ`, `tag`, `fields`. Reflection functions renamed to avoid Erlang BIF
+  clashes: `is_tuple` → `is_tuple_type`, `is_function` → `is_function_type`. Union tag matching
+  uses integer tags (matching Beam's `{0, Field1, Field2}` representation). `MakeRecord`/
+  `MakeUnion` handle both plain lists and process-dict ref arrays. `GetRecordFields` resolves
+  concrete types through `TypeCast` wrappers via `getConcreteType` helper.
+- **Async error wrapping**: `wrap_error/1` in `fable_async.erl` normalizes raw errors so
+  `.Message` accessor works: raw binaries (from `failwith`) → `#{message => Bin}`, maps
+  (from `raise (exn ...)`) pass through, refs pass through, everything else → formatted map.
+  Used in `catch_async`, `try_with`, and `try_finally`. `catch_async` uses integer tags
+  `{0, V}` / `{1, wrap_error(E)}` matching Beam's Choice union representation.
+- **OperationCanceledException**: Added to the exception type pattern in Beam Replacements
+  alongside `BuiltinSystemException` and `KeyNotFoundException`.
 
 ## Future Improvements
 

src/Fable.Transforms/Beam/Fable2Beam.Reflection.fs

@@ -13,6 +13,10 @@ let private strLit s =
 let private atomLit s =
     Beam.ErlExpr.Literal(Beam.ErlLiteral.AtomLit(Beam.Atom s))
 
+/// Create an integer literal Erlang expression
+let private intLit i =
+    Beam.ErlExpr.Literal(Beam.ErlLiteral.Integer(int64 i))
+
 /// Build a type info map: #{fullname => <<"...">>, generics => [...]}
 let private makeTypeInfoMap (fullname: string) (generics: Beam.ErlExpr list) =
     Beam.ErlExpr.Map
@@ -21,6 +25,23 @@ let private makeTypeInfoMap (fullname: string) (generics: Beam.ErlExpr list) =
             atomLit "generics", Beam.ErlExpr.List generics
         ]
 
+/// Build a PropertyInfo map: #{name => <<"field_name">>, property_type => TypeInfo}
+let private makePropertyInfo (fieldName: string) (typeInfo: Beam.ErlExpr) =
+    let erlName = Fable.Beam.Naming.sanitizeErlangName fieldName
+    Beam.ErlExpr.Map [ atomLit "name", strLit erlName; atomLit "property_type", typeInfo ]
+
+/// Build a CaseInfo map: #{tag => N, name => <<"CaseName">>, erl_tag => case_name, fields => [...]}
+let private makeCaseInfo (tag: int) (caseName: string) (fields: Beam.ErlExpr list) =
+    let erlTag = Fable.Beam.Naming.sanitizeErlangName caseName
+
+    Beam.ErlExpr.Map
+        [
+            atomLit "tag", intLit tag
+            atomLit "name", strLit caseName
+            atomLit "erl_tag", atomLit erlTag
+            atomLit "fields", Beam.ErlExpr.List fields
+        ]
+
 /// Get the full name for a number kind
 let private getNumberFullName (kind: NumberKind) =
     match kind with
@@ -101,4 +122,40 @@ let rec transformTypeInfo
     | Fable.AnonymousRecordType _ -> makeTypeInfoMap "" []
     | Fable.DeclaredType(entRef, generics) ->
         let resolved = resolveGenerics generics
-        makeTypeInfoMap entRef.FullName resolved
+
+        match com.TryGetEntity(entRef) with
+        | Some ent when ent.IsFSharpRecord ->
+            let fields =
+                ent.FSharpFields
+                |> List.map (fun fi ->
+                    let typeInfo = transformTypeInfo com r genMap fi.FieldType
+                    makePropertyInfo fi.Name typeInfo
+                )
+
+            Beam.ErlExpr.Map
+                [
+                    atomLit "fullname", strLit entRef.FullName
+                    atomLit "generics", Beam.ErlExpr.List resolved
+                    atomLit "fields", Beam.ErlExpr.List fields
+                ]
+        | Some ent when ent.IsFSharpUnion ->
+            let cases =
+                ent.UnionCases
+                |> List.mapi (fun i uci ->
+                    let caseFields =
+                        uci.UnionCaseFields
+                        |> List.map (fun fi ->
+                            let typeInfo = transformTypeInfo com r genMap fi.FieldType
+                            makePropertyInfo fi.Name typeInfo
+                        )
+
+                    makeCaseInfo i uci.Name caseFields
+                )
+
+            Beam.ErlExpr.Map
+                [
+                    atomLit "fullname", strLit entRef.FullName
+                    atomLit "generics", Beam.ErlExpr.List resolved
+                    atomLit "cases", Beam.ErlExpr.List cases
+                ]
+        | _ -> makeTypeInfoMap entRef.FullName resolved

src/Fable.Transforms/Beam/Fable2Beam.Util.fs

@@ -57,6 +57,17 @@ let rec containsIdentRef (name: string) (expr: Expr) : bool =
     | Test(e, _, _) -> containsIdentRef name e
     | Get(e, _, _, _) -> containsIdentRef name e
     | Set(e, _, _, v, _) -> containsIdentRef name e || containsIdentRef name v
+    | WhileLoop(guard, body, _) -> containsIdentRef name guard || containsIdentRef name body
+    | ForLoop(_, start, limit, body, _, _) ->
+        containsIdentRef name start
+        || containsIdentRef name limit
+        || containsIdentRef name body
+    | TryCatch(body, catch, finalizer, _) ->
+        containsIdentRef name body
+        || (catch
+            |> Option.map (fun (_, e) -> containsIdentRef name e)
+            |> Option.defaultValue false)
+        || (finalizer |> Option.map (containsIdentRef name) |> Option.defaultValue false)
     | Emit(emitInfo, _, _) -> emitInfo.CallInfo.Args |> List.exists (containsIdentRef name)
     | ObjectExpr(members, _, baseCall) ->
         members |> List.exists (fun m -> containsIdentRef name m.Body)
@@ -103,6 +114,14 @@ let isCapturedInClosure (name: string) (expr: Expr) : bool =
         | Test(e, _, _) -> check inClosure e
         | Get(e, _, _, _) -> check inClosure e
         | Set(e, _, _, v, _) -> check inClosure e || check inClosure v
+        | WhileLoop(guard, body, _) -> check inClosure guard || check inClosure body
+        | ForLoop(_, start, limit, body, _, _) -> check inClosure start || check inClosure limit || check inClosure body
+        | TryCatch(body, catch, finalizer, _) ->
+            check inClosure body
+            || (catch
+                |> Option.map (fun (_, e) -> check inClosure e)
+                |> Option.defaultValue false)
+            || (finalizer |> Option.map (check inClosure) |> Option.defaultValue false)
         | Emit(emitInfo, _, _) -> emitInfo.CallInfo.Args |> List.exists (check inClosure)
         | ObjectExpr(members, _, baseCall) ->
             members |> List.exists (fun m -> check true m.Body)

src/Fable.Transforms/Beam/Fable2Beam.fs

@@ -265,8 +265,11 @@ let rec transformExpr (com: IBeamCompiler) (ctx: Context) (expr: Expr) : Beam.Er
             let allHoisted = appliedHoisted @ argsHoisted
 
             let result =
-                cleanArgs
-                |> List.fold (fun fn arg -> Beam.ErlExpr.Apply(fn, [ arg ])) cleanApplied
+                match cleanArgs with
+                | [] -> Beam.ErlExpr.Apply(cleanApplied, [])
+                | _ ->
+                    cleanArgs
+                    |> List.fold (fun fn arg -> Beam.ErlExpr.Apply(fn, [ arg ])) cleanApplied
 
             result |> wrapWithHoisted allHoisted
 
@@ -541,6 +544,8 @@ let rec transformExpr (com: IBeamCompiler) (ctx: Context) (expr: Expr) : Beam.Er
                     lambdaBody,
                     { ctx' with LocalVars = ctx'.LocalVars.Add(arg.Name) }
                 | Delegate(args, lambdaBody, _, _) ->
+                    let args = FSharp2Fable.Util.discardUnitArg args
+
                     args
                     |> List.map (fun a -> Beam.PVar(capitalizeFirst a.Name |> sanitizeErlangVar)),
                     args,
@@ -966,15 +971,6 @@ let rec transformExpr (com: IBeamCompiler) (ctx: Context) (expr: Expr) : Beam.Er
                     }
                 ]
 
-    | _ ->
-        let exprName = expr.GetType().Name
-
-        com.WarnOnlyOnce(
-            $"Unhandled Fable expression type '%s{exprName}' — emitting placeholder atom. This may cause runtime errors."
-        )
-
-        Beam.ErlExpr.Literal(Beam.ErlLiteral.AtomLit(Beam.Atom $"todo_%s{exprName.ToLowerInvariant()}"))
-
 and transformValue (com: IBeamCompiler) (ctx: Context) (value: ValueKind) : Beam.ErlExpr =
     match value with
     | StringConstant s -> Beam.ErlExpr.Literal(Beam.ErlLiteral.StringLit s)
@@ -1071,13 +1067,11 @@ and transformValue (com: IBeamCompiler) (ctx: Context) (value: ValueKind) : Beam
         let erlValue = transformExpr com ctx value
 
         match typ with
-        | GenericParam _
-        | Any ->
-            // Runtime decision: use smart constructor that wraps only ambiguous values
-            Beam.ErlExpr.Call(Some "fable_option", "some", [ erlValue ])
         | _ when mustWrapOption typ ->
-            // Compile-time decision: we know wrapping is needed (e.g., Option<Option<T>>)
-            Beam.ErlExpr.Tuple [ Beam.ErlExpr.Literal(Beam.ErlLiteral.AtomLit(Beam.Atom "some")); erlValue ]
+            // Use runtime smart constructor for consistency with library code (e.g., tryHead).
+            // Both the compiler-generated values and library-produced values go through the
+            // same fable_option:some/1, ensuring equal representation for nested options.
+            Beam.ErlExpr.Call(Some "fable_option", "some", [ erlValue ])
         | _ -> erlValue
 
     | NewOption(None, _typ, _isStruct) -> Beam.ErlExpr.Literal(Beam.ErlLiteral.AtomLit(Beam.Atom "undefined"))
@@ -1109,6 +1103,7 @@ and transformValue (com: IBeamCompiler) (ctx: Context) (value: ValueKind) : Beam
             Beam.ErlExpr.Literal(Beam.ErlLiteral.Float d)
     | NumberConstant(NumberValue.NativeInt i, _) -> Beam.ErlExpr.Literal(Beam.ErlLiteral.Integer(int64 i))
     | NumberConstant(NumberValue.UNativeInt i, _) -> Beam.ErlExpr.Literal(Beam.ErlLiteral.Integer(int64 i))
+    | NumberConstant(NumberValue.BigInt i, _) -> Beam.ErlExpr.Literal(Beam.ErlLiteral.BigInt(string<bigint> i))
     | NumberConstant(NumberValue.Decimal d, _) ->
         // Decimal as fixed-scale integer: value × 10^28
         let bits = System.Decimal.GetBits(d)
@@ -1869,8 +1864,28 @@ and transformCall (com: IBeamCompiler) (ctx: Context) (callee: Expr) (info: Call
             Beam.ErlExpr.Apply(bundleCall, allArgs) |> wrapWithHoisted allHoisted
         | None ->
             if ctx.RecursiveBindings.Contains(ident.Name) || ctx.LocalVars.Contains(ident.Name) then
-                Beam.ErlExpr.Apply(Beam.ErlExpr.Variable(capitalizeFirst ident.Name |> sanitizeErlangVar), allArgs)
-                |> wrapWithHoisted allHoisted
+                let varExpr = Beam.ErlExpr.Variable(capitalizeFirst ident.Name |> sanitizeErlangVar)
+
+                let apply =
+                    match allArgs with
+                    | [] when
+                        (match ident.Type with
+                         | Fable.AST.Fable.Type.DelegateType _ -> true
+                         | _ -> false)
+                        ->
+                        // Zero-arg delegate Invoke (e.g. `d.Invoke()` on `delegate of unit -> int`).
+                        // The underlying fun may be arity 0 (unit stripped at definition by discardUnitArg)
+                        // or arity 1 (unit kept in Delegate AST node). Erlang enforces arity, so check
+                        // at runtime. This is necessary because the Delegate AST node is shared by .NET
+                        // delegates (Invoke strips unit via dropUnitCallArg) and callbacks like Lazy
+                        // factories (called with explicit unit), preventing a uniform compile-time fix.
+                        Beam.ErlExpr.Emit(
+                            "case erlang:fun_info($0, arity) of {arity, 0} -> ($0)(); {arity, _} -> ($0)(ok) end",
+                            [ varExpr ]
+                        )
+                    | _ -> Beam.ErlExpr.Apply(varExpr, allArgs)
+
+                apply |> wrapWithHoisted allHoisted
             else
                 Beam.ErlExpr.Call(None, sanitizeErlangName ident.Name, allArgs)
                 |> wrapWithHoisted allHoisted