[Beam] Fix ImportAll generating invalid Erlang when used as value (#4412)

Author: dbrattli

src/Fable.Cli/CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * [Beam] Fix "no effect" warning for pure BIF calls (`self/0`, `node/0`) in non-final block positions (by @dbrattli)
 * [Beam] Fix `reraise()` generating unbound `MatchValue` variable — use raw Erlang reason variable for re-throw (by @dbrattli)
 * [Beam] Fix `Erlang.receive<'T>()` resolving to timeout overload due to F# unit argument (by @dbrattli)
+* [Beam] Fix `[<ImportAll>]` generating invalid `module:*()` Erlang code when binding is used as a value (by @dbrattli)
 
 ## 5.0.0-rc.3 - 2026-03-10
 

src/Fable.Compiler/CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * [Beam] Fix "no effect" warning for pure BIF calls (`self/0`, `node/0`) in non-final block positions (by @dbrattli)
 * [Beam] Fix `reraise()` generating unbound `MatchValue` variable — use raw Erlang reason variable for re-throw (by @dbrattli)
 * [Beam] Fix `Erlang.receive<'T>()` resolving to timeout overload due to F# unit argument (by @dbrattli)
+* [Beam] Fix `[<ImportAll>]` generating invalid `module:*()` Erlang code when binding is used as a value (by @dbrattli)
 
 ## 5.0.0-rc.10 - 2026-03-10
 

src/Fable.Transforms/Beam/Fable2Beam.fs

@@ -1189,52 +1189,66 @@ let rec transformExpr (com: IBeamCompiler) (ctx: Context) (expr: Expr) : Beam.Er
             Beam.ErlExpr.Literal(Beam.ErlLiteral.AtomLit(Beam.Atom "ok"))
 
     | Import(importInfo, typ, _range) ->
-        // Standalone import (function reference from another module, not a direct call).
-        // Generate a lambda wrapper: fun(A1, ..., AN) -> module:function(A1, ..., AN) end
         let moduleName = resolveImportModuleName com importInfo.Path
 
-        let funcName = sanitizeErlangName importInfo.Selector
-
-        // Count arity from the function type (follows all nested LambdaType levels)
-        let rec functionArity (t: Fable.AST.Fable.Type) =
-            match t with
-            | Fable.AST.Fable.Type.LambdaType(_, returnType) -> 1 + functionArity returnType
-            | Fable.AST.Fable.Type.DelegateType(argTypes, _) -> argTypes.Length
-            | _ -> 0
-
-        // Determine the actual Erlang arity of the imported function.
-        // For MemberImport, use NonCurriedArgTypes which gives us the actual parameter count.
-        // This is critical because functionArity(typ) follows the full curried type chain
-        // (including return type nesting), which over-counts when the return type is itself
-        // a function type (e.g., HttpHandler -> HttpHandler -> HttpHandler where HttpHandler
-        // is a function type — functionArity returns 4 but actual Erlang arity is 2).
-        let arity =
-            match importInfo.Kind with
-            | Fable.AST.Fable.MemberImport(Fable.AST.Fable.MemberRef(_, info)) ->
-                match info.NonCurriedArgTypes with
-                | Some argTypes -> argTypes.Length
-                | None -> 0 // Value binding (no explicit params) → 0-arity in Erlang
-            | _ -> functionArity typ
-
-        if arity = 0 then
-            // Not a function or value binding — call with no args to get the value
-            Beam.ErlExpr.Call(moduleName, funcName, [])
-        else
-            // Generate lambda wrapper for the function reference
-            let counter = com.IncrementCounter()
-
-            let argNames = List.init arity (fun i -> $"Import_arg_%d{i}_%d{counter}")
-            let argPats = argNames |> List.map Beam.PVar
-            let argExprs = argNames |> List.map Beam.ErlExpr.Variable
+        if importInfo.Selector = "*" then
+            // ImportAll: represents a whole module (e.g., [<ImportAll("maps")>] let maps: IMaps = nativeOnly).
+            // When used as a value (assigned to variable), generate a tagged tuple
+            // {fable_import_all, module_atom} that fable_utils:iface_get recognizes
+            // and dispatches dynamically via erlang:make_fun/3.
+            let modAtom =
+                Beam.ErlExpr.Literal(Beam.ErlLiteral.AtomLit(Beam.Atom(moduleName |> Option.defaultValue "unknown")))
 
-            Beam.ErlExpr.Fun
+            Beam.ErlExpr.Tuple
                 [
-                    {
-                        Patterns = argPats
-                        Guard = []
-                        Body = [ Beam.ErlExpr.Call(moduleName, funcName, argExprs) ]
-                    }
+                    Beam.ErlExpr.Literal(Beam.ErlLiteral.AtomLit(Beam.Atom "fable_import_all"))
+                    modAtom
                 ]
+        else
+            // Standalone import (function reference from another module, not a direct call).
+            // Generate a lambda wrapper: fun(A1, ..., AN) -> module:function(A1, ..., AN) end
+            let funcName = sanitizeErlangName importInfo.Selector
+
+            // Count arity from the function type (follows all nested LambdaType levels)
+            let rec functionArity (t: Fable.AST.Fable.Type) =
+                match t with
+                | Fable.AST.Fable.Type.LambdaType(_, returnType) -> 1 + functionArity returnType
+                | Fable.AST.Fable.Type.DelegateType(argTypes, _) -> argTypes.Length
+                | _ -> 0
+
+            // Determine the actual Erlang arity of the imported function.
+            // For MemberImport, use NonCurriedArgTypes which gives us the actual parameter count.
+            // This is critical because functionArity(typ) follows the full curried type chain
+            // (including return type nesting), which over-counts when the return type is itself
+            // a function type (e.g., HttpHandler -> HttpHandler -> HttpHandler where HttpHandler
+            // is a function type — functionArity returns 4 but actual Erlang arity is 2).
+            let arity =
+                match importInfo.Kind with
+                | Fable.AST.Fable.MemberImport(Fable.AST.Fable.MemberRef(_, info)) ->
+                    match info.NonCurriedArgTypes with
+                    | Some argTypes -> argTypes.Length
+                    | None -> 0 // Value binding (no explicit params) → 0-arity in Erlang
+                | _ -> functionArity typ
+
+            if arity = 0 then
+                // Not a function or value binding — call with no args to get the value
+                Beam.ErlExpr.Call(moduleName, funcName, [])
+            else
+                // Generate lambda wrapper for the function reference
+                let counter = com.IncrementCounter()
+
+                let argNames = List.init arity (fun i -> $"Import_arg_%d{i}_%d{counter}")
+                let argPats = argNames |> List.map Beam.PVar
+                let argExprs = argNames |> List.map Beam.ErlExpr.Variable
+
+                Beam.ErlExpr.Fun
+                    [
+                        {
+                            Patterns = argPats
+                            Guard = []
+                            Body = [ Beam.ErlExpr.Call(moduleName, funcName, argExprs) ]
+                        }
+                    ]
 
 and transformValue (com: IBeamCompiler) (ctx: Context) (value: ValueKind) : Beam.ErlExpr =
     match value with
@@ -2313,6 +2327,18 @@ and transformCall (com: IBeamCompiler) (ctx: Context) (callee: Expr) (info: Call
             | "toSeq" -> Beam.ErlExpr.Call(Some "maps", "to_list", cleanArgs)
             | _ -> Beam.ErlExpr.Call(Some "maps", sanitizeErlangName selector, cleanArgs)
             |> wrapWithHoisted hoisted
+        | "*" ->
+            // ImportAll: selector is "*" meaning the callee is a whole-module import.
+            // Use MemberRef to get the actual function name being called.
+            match info.MemberRef with
+            | Some(Fable.AST.Fable.MemberRef(_, memberInfo)) ->
+                let funcName = sanitizeErlangName memberInfo.CompiledName
+                let args = info.Args |> List.map (transformExpr com ctx)
+                let hoisted, cleanArgs = hoistBlocksFromArgs args
+
+                Beam.ErlExpr.Call(importModuleName, funcName, cleanArgs)
+                |> wrapWithHoisted hoisted
+            | _ -> failwith "ImportAll call without MemberRef — cannot resolve function name"
         | selector ->
             let args = info.Args |> List.map (transformExpr com ctx)
             let hoisted, cleanArgs = hoistBlocksFromArgs args
@@ -2436,12 +2462,14 @@ and transformCall (com: IBeamCompiler) (ctx: Context) (callee: Expr) (info: Call
             let allHoisted = calleeHoisted @ argsHoisted
 
             if isInterfaceExpr then
-                // Interface method dispatch: (fable_utils:iface_get(method_name, Obj))(Args)
-                // Works for both object expressions (maps) and class instances (refs)
+                // Interface method dispatch: (fable_utils:iface_get(method_name, arity, Obj))(Args)
+                // Works for object expressions (maps), class instances (refs), and ImportAll modules.
+                // Passing arity resolves ambiguity when a module exports the same name at multiple arities.
                 let methodAtom = atomLit (sanitizeErlangName fieldInfo.Name)
+                let arityLit = Beam.ErlExpr.Literal(Beam.ErlLiteral.Integer(int64 cleanArgs.Length))
 
                 let lookup =
-                    Beam.ErlExpr.Call(Some "fable_utils", "iface_get", [ methodAtom; cleanCallee ])
+                    Beam.ErlExpr.Call(Some "fable_utils", "iface_get", [ methodAtom; arityLit; cleanCallee ])
 
                 Beam.ErlExpr.Apply(lookup, cleanArgs) |> wrapWithHoisted allHoisted
             else

src/fable-library-beam/fable_utils.erl

@@ -1,6 +1,7 @@
 -module(fable_utils).
 -export([
     iface_get/2,
+    iface_get/3,
     apply_curried/2,
     new_ref/1,
     safe_dispose/1,
@@ -29,7 +30,8 @@
     div_rem/3
 ]).
 
--spec iface_get(atom(), map() | reference()) -> term().
+-spec iface_get(atom(), map() | reference() | {fable_import_all, atom()}) -> term().
+-spec iface_get(atom(), non_neg_integer(), {fable_import_all, atom()}) -> term().
 -spec apply_curried(fun(), list()) -> term().
 -spec new_ref(term()) -> reference().
 -spec safe_dispose(term()) -> ok.
@@ -60,6 +62,20 @@
 %% Interface dispatch: works for both object expressions (maps) and class instances (refs).
 %% Class interface property getters are stored as {getter, Fun} tagged thunks — call Fun().
 %% ObjectExpr property getters are stored as plain values — return directly.
+%% ImportAll modules are tagged as {fable_import_all, ModuleAtom} and dispatched via
+%% erlang:make_fun/3. The 3-arity overload passes explicit arity to avoid ambiguity
+%% when a module exports the same name at multiple arities (e.g., maps:get/2 and get/3).
+iface_get(Name, Arity, {fable_import_all, Mod}) ->
+    erlang:make_fun(Mod, Name, Arity);
+iface_get(Name, _Arity, Obj) ->
+    iface_get(Name, Obj).
+
+iface_get(Name, {fable_import_all, Mod}) ->
+    Exports = Mod:module_info(exports),
+    case lists:keyfind(Name, 1, Exports) of
+        {Name, Arity} -> erlang:make_fun(Mod, Name, Arity);
+        false -> erlang:error({no_export, Mod, Name})
+    end;
 iface_get(Name, Obj) when is_map(Obj) -> iface_unwrap(maps:get(Name, Obj));
 iface_get(Name, Ref) -> iface_unwrap(maps:get(Name, get(Ref))).
 

tests/Beam/InteropTests.fs

@@ -54,6 +54,15 @@ type INativeCode =
 [<ImportAll("native_code")>]
 let nativeCode: INativeCode = nativeOnly
 
+// ImportAll with Erlang stdlib module (maps)
+[<Erase>]
+type IMaps =
+    abstract from_list: list: obj -> obj
+    abstract get: key: obj * map: obj -> obj
+
+[<ImportAll("maps")>]
+let erlangMaps: IMaps = nativeOnly
+
 // ============================================================
 // Erased union tests
 // ============================================================
@@ -222,6 +231,38 @@ let ``test ImportAll with Erase interface calls string method`` () =
     ()
 #endif
 
+[<Fact>]
+let ``test ImportAll with stdlib module single-arg method`` () =
+#if FABLE_COMPILER
+    // maps:from_list([{key, value}]) should work via ImportAll
+    let list: obj = emitErlExpr () "[{<<\"a\">>, 1}]"
+    let result = erlangMaps.from_list(list)
+    let value: obj = erlangMaps.get(box "a", result)
+    equal 1 (unbox<int> value)
+#else
+    ()
+#endif
+
+[<Fact>]
+let ``test ImportAll binding assigned to local variable`` () =
+#if FABLE_COMPILER
+    // Test that ImportAll works when assigned to a local let binding
+    let m = nativeCode
+    m.getName () |> equal "native_code"  // 0-arity (property-style)
+    m.addValues (3, 4) |> equal 7        // multi-arg method
+#else
+    ()
+#endif
+
+[<Fact>]
+let ``test ImportAll used with pipe operator`` () =
+#if FABLE_COMPILER
+    // Test that ImportAll works when used in a pipeline
+    (3, 4) |> nativeCode.addValues |> equal 7
+#else
+    ()
+#endif
+
 [<Fact>]
 let ``test Erased types can have members`` () =
 #if FABLE_COMPILER