[Beam] Format source files and suppress build warnings (#4356)

Author: dbrattli

src/Fable.Build/Test/Beam.fs

@@ -75,7 +75,11 @@ let handle (args: string list) =
                 let fileName = Path.GetFileName(erlFile)
 
                 try
-                    Command.Run("erlc", fileName, workingDirectory = fableModulesLibDir)
+                    Command.Run(
+                        "erlc",
+                        $"+nowarn_ignored +nowarn_failed +nowarn_shadow_vars {fileName}",
+                        workingDirectory = fableModulesLibDir
+                    )
                 with _ ->
                     printfn $"WARNING: erlc failed for {fileName} (library), skipping"
                     compileErrors <- compileErrors + 1
@@ -87,7 +91,11 @@ let handle (args: string list) =
             let fileName = Path.GetFileName(erlFile)
 
             try
-                Command.Run("erlc", $"-pa fable_modules/fable-library-beam {fileName}", workingDirectory = buildDir)
+                Command.Run(
+                    "erlc",
+                    $"+nowarn_ignored +nowarn_failed +nowarn_shadow_vars -pa fable_modules/fable-library-beam {fileName}",
+                    workingDirectory = buildDir
+                )
             with _ ->
                 printfn $"WARNING: erlc failed for {fileName}, skipping"
                 compileErrors <- compileErrors + 1

src/fable-library-beam/fable_async.erl

@@ -1,22 +1,35 @@
 -module(fable_async).
--export([start_immediate/1, start_immediate/2,
-         run_synchronously/1, run_synchronously/2,
-         start_with_continuations/4, start_with_continuations/5,
-         sleep/1, parallel/1, sequential/1,
-         catch_async/1, ignore/1, from_continuations/1,
-         start_as_task/1,
-         cancellation_token/0, create_cancellation_token/0, create_cancellation_token/1,
-         wrap_error/1]).
-
--type async_ctx() :: #{on_success := fun(), on_error := fun(), on_cancel := fun(), cancel_token := reference() | undefined}.
+-export([
+    start_immediate/1, start_immediate/2,
+    run_synchronously/1, run_synchronously/2,
+    start_with_continuations/4, start_with_continuations/5,
+    sleep/1,
+    parallel/1,
+    sequential/1,
+    catch_async/1,
+    ignore/1,
+    from_continuations/1,
+    start_as_task/1,
+    cancellation_token/0,
+    create_cancellation_token/0, create_cancellation_token/1,
+    wrap_error/1
+]).
+
+-type async_ctx() :: #{
+    on_success := fun(),
+    on_error := fun(),
+    on_cancel := fun(),
+    cancel_token := reference() | undefined
+}.
 -type async(T) :: fun((async_ctx()) -> T).
 
 -spec start_immediate(async(term())) -> term().
 -spec start_immediate(async(term()), reference() | undefined) -> term().
 -spec run_synchronously(async(term())) -> term().
 -spec run_synchronously(async(term()), reference() | undefined) -> term().
 -spec start_with_continuations(async(term()), fun(), fun(), fun()) -> term().
--spec start_with_continuations(async(term()), fun(), fun(), fun(), reference() | undefined) -> term().
+-spec start_with_continuations(async(term()), fun(), fun(), fun(), reference() | undefined) ->
+    term().
 -spec sleep(non_neg_integer()) -> async(ok).
 -spec parallel(list() | reference()) -> async(reference()).
 -spec sequential(list()) -> async(list()).
@@ -30,10 +43,12 @@
 
 %% Default context: run inline in current process
 default_ctx(CancelToken) ->
-    #{on_success => fun(_) -> ok end,
-      on_error => fun(E) -> erlang:error(E) end,
-      on_cancel => fun(_) -> ok end,
-      cancel_token => CancelToken}.
+    #{
+        on_success => fun(_) -> ok end,
+        on_error => fun(E) -> erlang:error(E) end,
+        on_cancel => fun(_) -> ok end,
+        cancel_token => CancelToken
+    }.
 
 %% StartImmediate: run with default context (fire-and-forget)
 start_immediate(Computation) -> start_immediate(Computation, undefined).
@@ -45,12 +60,16 @@ run_synchronously(Computation) -> run_synchronously(Computation, undefined).
 run_synchronously(Computation, CancelToken) ->
     %% Use a unique ref as key to store result in process dict
     Ref = make_ref(),
-    Ctx = #{on_success => fun(V) -> put(Ref, {ok, V}) end,
-            on_error => fun(E) -> put(Ref, {error, E}) end,
-            on_cancel => fun(_) -> put(Ref, {cancelled}) end,
-            cancel_token => CancelToken},
-    try Computation(Ctx)
-    catch _:Err -> put(Ref, {error, Err})
+    Ctx = #{
+        on_success => fun(V) -> put(Ref, {ok, V}) end,
+        on_error => fun(E) -> put(Ref, {error, E}) end,
+        on_cancel => fun(_) -> put(Ref, {cancelled}) end,
+        cancel_token => CancelToken
+    },
+    try
+        Computation(Ctx)
+    catch
+        _:Err -> put(Ref, {error, Err})
     end,
     Result = erase(Ref),
     case Result of
@@ -64,10 +83,16 @@ run_synchronously(Computation, CancelToken) ->
 start_with_continuations(Comp, OnSuccess, OnError, OnCancel) ->
     start_with_continuations(Comp, OnSuccess, OnError, OnCancel, undefined).
 start_with_continuations(Comp, OnSuccess, OnError, OnCancel, Token) ->
-    Ctx = #{on_success => OnSuccess, on_error => OnError,
-            on_cancel => OnCancel, cancel_token => Token},
-    try Comp(Ctx)
-    catch _:Err -> OnError(Err)
+    Ctx = #{
+        on_success => OnSuccess,
+        on_error => OnError,
+        on_cancel => OnCancel,
+        cancel_token => Token
+    },
+    try
+        Comp(Ctx)
+    catch
+        _:Err -> OnError(Err)
     end.
 
 %% Sleep: pause current process, with cancellation support
@@ -119,16 +144,20 @@ parallel(Computations) ->
     fun(Ctx) ->
         Self = self(),
         Indexed = lists:zip(lists:seq(1, length(Computations)), Computations),
-        lists:foreach(fun({Idx, Comp}) ->
-            spawn(fun() ->
-                try
-                    Result = fable_async:run_synchronously(Comp),
-                    Self ! {async_parallel, Idx, {ok, Result}}
-                catch _:Err ->
-                    Self ! {async_parallel, Idx, {error, Err}}
-                end
-            end)
-        end, Indexed),
+        lists:foreach(
+            fun({Idx, Comp}) ->
+                spawn(fun() ->
+                    try
+                        Result = fable_async:run_synchronously(Comp),
+                        Self ! {async_parallel, Idx, {ok, Result}}
+                    catch
+                        _:Err ->
+                            Self ! {async_parallel, Idx, {error, Err}}
+                    end
+                end)
+            end,
+            Indexed
+        ),
         Results = collect_parallel(length(Computations), #{}),
         case Results of
             {ok, Map} ->
@@ -139,7 +168,8 @@ parallel(Computations) ->
         end
     end.
 
-collect_parallel(0, Acc) -> {ok, Acc};
+collect_parallel(0, Acc) ->
+    {ok, Acc};
 collect_parallel(N, Acc) ->
     receive
         {async_parallel, Idx, {ok, Val}} ->
@@ -165,8 +195,10 @@ catch_async(Computation) ->
             on_cancel => maps:get(on_cancel, Ctx),
             cancel_token => maps:get(cancel_token, Ctx)
         },
-        try Computation(Ctx2)
-        catch _:Err -> (maps:get(on_success, Ctx))({choice2_of2, wrap_error(Err)})
+        try
+            Computation(Ctx2)
+        catch
+            _:Err -> (maps:get(on_success, Ctx))({choice2_of2, wrap_error(Err)})
         end
     end.
 

src/fable-library-beam/fable_async_builder.erl

@@ -1,9 +1,20 @@
 -module(fable_async_builder).
--export([singleton/0, singleton/1, task/0, task/1, run/1,
-         delay/1, return/1, return_from/1,
-         bind/2, combine/2, zero/0, zero/1,
-         try_with/2, try_finally/2, using/2,
-         while/2, for/2]).
+-export([
+    singleton/0, singleton/1,
+    task/0, task/1,
+    run/1,
+    delay/1,
+    return/1,
+    return_from/1,
+    bind/2,
+    combine/2,
+    zero/0, zero/1,
+    try_with/2,
+    try_finally/2,
+    using/2,
+    while/2,
+    for/2
+]).
 
 -spec singleton() -> async_builder.
 -spec singleton(term()) -> async_builder.
@@ -52,11 +63,15 @@ delay(Generator) ->
 %% Bind: monadic bind — run computation, pass result to binder
 bind(Computation, Binder) ->
     fun(Ctx) ->
-        Ctx2 = Ctx#{on_success => fun(X) ->
-            try (Binder(X))(Ctx)
-            catch _:Err -> (maps:get(on_error, Ctx))(Err)
+        Ctx2 = Ctx#{
+            on_success => fun(X) ->
+                try
+                    (Binder(X))(Ctx)
+                catch
+                    _:Err -> (maps:get(on_error, Ctx))(Err)
+                end
             end
-        end},
+        },
         Computation(Ctx2)
     end.
 
@@ -68,18 +83,26 @@ combine(Comp1, Comp2) ->
 %% Wrap raw errors (binaries from failwith) as exception maps so .Message works.
 try_with(Computation, Handler) ->
     fun(Ctx) ->
-        Ctx2 = Ctx#{on_error => fun(Err) ->
-            Err2 = fable_async:wrap_error(Err),
-            try (Handler(Err2))(Ctx)
-            catch _:Err3 -> (maps:get(on_error, Ctx))(Err3)
-            end
-        end},
-        try Computation(Ctx2)
-        catch _:Err ->
-            Err2 = fable_async:wrap_error(Err),
-            try (Handler(Err2))(Ctx)
-            catch _:Err3 -> (maps:get(on_error, Ctx))(Err3)
+        Ctx2 = Ctx#{
+            on_error => fun(Err) ->
+                Err2 = fable_async:wrap_error(Err),
+                try
+                    (Handler(Err2))(Ctx)
+                catch
+                    _:Err3 -> (maps:get(on_error, Ctx))(Err3)
+                end
             end
+        },
+        try
+            Computation(Ctx2)
+        catch
+            _:Err ->
+                Err2 = fable_async:wrap_error(Err),
+                try
+                    (Handler(Err2))(Ctx)
+                catch
+                    _:Err3 -> (maps:get(on_error, Ctx))(Err3)
+                end
         end
     end.
 
@@ -88,12 +111,25 @@ try_with(Computation, Handler) ->
 try_finally(Computation, Compensation) ->
     fun(Ctx) ->
         Ctx2 = Ctx#{
-            on_success => fun(X) -> Compensation(ok), (maps:get(on_success, Ctx))(X) end,
-            on_error => fun(E) -> Compensation(ok), (maps:get(on_error, Ctx))(E) end,
-            on_cancel => fun(E) -> Compensation(ok), (maps:get(on_cancel, Ctx))(E) end
+            on_success => fun(X) ->
+                Compensation(ok),
+                (maps:get(on_success, Ctx))(X)
+            end,
+            on_error => fun(E) ->
+                Compensation(ok),
+                (maps:get(on_error, Ctx))(E)
+            end,
+            on_cancel => fun(E) ->
+                Compensation(ok),
+                (maps:get(on_cancel, Ctx))(E)
+            end
         },
-        try Computation(Ctx2)
-        catch _:Err -> Compensation(ok), (maps:get(on_error, Ctx))(Err)
+        try
+            Computation(Ctx2)
+        catch
+            _:Err ->
+                Compensation(ok),
+                (maps:get(on_error, Ctx))(Err)
         end
     end.
 
@@ -114,5 +150,5 @@ for(List, Body) when is_reference(List) ->
 for(List, Body) ->
     case List of
         [] -> zero();
-        [H|T] -> bind(Body(H), fun(_) -> for(T, Body) end)
+        [H | T] -> bind(Body(H), fun(_) -> for(T, Body) end)
     end.

src/fable-library-beam/fable_bit_converter.erl

@@ -1,7 +1,15 @@
 -module(fable_bit_converter).
--export([get_bytes/2, get_bytes_bool/1, to_int/3, to_uint/3, to_float/3,
-         to_boolean/2, to_string/1, to_string/2, to_string/3,
-         int64_bits_to_double/1, double_to_int64_bits/1]).
+-export([
+    get_bytes/2,
+    get_bytes_bool/1,
+    to_int/3,
+    to_uint/3,
+    to_float/3,
+    to_boolean/2,
+    to_string/1, to_string/2, to_string/3,
+    int64_bits_to_double/1,
+    double_to_int64_bits/1
+]).
 
 -spec get_bytes(integer() | float(), integer()) -> tuple().
 -spec get_bytes_bool(boolean()) -> tuple().