[Rust] Support Rust module imports (fable-compiler#2951)

* [Rust] Don't output empty modules

* [Rust] Support direct imports

Author: ncave

src/Fable.Core/Fable.Core.Rust.fs

@@ -20,11 +20,22 @@ type InnerAttrAttribute private (name: string, value: string option, items: stri
     new (name: string, value: string) = InnerAttrAttribute(name, Some value, [||])
     new (name: string, items: string[]) = InnerAttrAttribute(name, None, items)
 
-
-//Rc/arc control
-type RefType =
+//Rc/Arc control
+type PointerType =
     | Rc = 0
     | Arc = 1
+
 // Rust - Defines the pointer type that is to be used to wrap the object (Rc/Arc)
-type ReferenceTypeAttribute(pointerType: RefType) =
-    inherit Attribute()
+type ReferenceTypeAttribute(pointerType: PointerType) =
+    inherit Attribute()
+
+/// Destructure a tuple of arguments and apply them to literal code as with EmitAttribute.
+/// E.g. `emitExpr (arg1, arg2) "$0 + $1"` becomes `arg1 + arg2`
+let emitExpr<'T> (args: obj) (code: string): 'T = nativeOnly
+
+/// Works like `ImportAttribute` (same semantics as Dart imports).
+/// You can use "*" selector.
+let import<'T> (selector: string) (path: string): 'T = nativeOnly
+
+/// Imports a whole external module.
+let importAll<'T> (path: string): 'T = nativeOnly

src/Fable.Transforms/Rust/Fable2Rust.fs

@@ -14,7 +14,7 @@ type Import =
   { Selector: string
     LocalIdent: string
     ModuleName: string
-    FullPath: string
+    ModulePath: string
     Path: string }
 
 type ITailCallOpportunity =
@@ -627,12 +627,14 @@ module TypeInfo =
                 | [:? string as macro] -> Some macro
                 | _ -> None
             else None)
+
     type PointerType =
         | Rc
         | Arc
+
     let (|HasReferenceTypeAttribute|_|) (ent: Fable.Entity) =
         ent.Attributes |> Seq.tryPick (fun att ->
-            if att.Entity.FullName.StartsWith(Atts.refType) then
+            if att.Entity.FullName.StartsWith(Atts.referenceType) then
                 match att.ConstructorArgs with
                 | [:? int as ptrType] ->
                     match ptrType with
@@ -2691,15 +2693,18 @@ module Util =
                     let relPath = Fable.Path.getRelativeFileOrDirPath false com.CurrentFile false filePath
                     com.GetImportName(ctx, "*", relPath, None) |> ignore
             )
-            let makeModItems (fullPath, moduleName) =
-                let importPath = Fable.Path.getRelativePath com.CurrentFile fullPath
-                let attrs = [mkEqAttr "path" importPath]
+            let makeModItems (modulePath, moduleName) =
+                let relPath = Fable.Path.getRelativePath com.CurrentFile modulePath
+                let attrs = [mkEqAttr "path" relPath]
                 let modItem = mkUnloadedModItem attrs moduleName
                 let useItem = mkGlobUseItem [] [moduleName]
                 if isFableLibrary com
                 then [modItem; useItem |> mkPublicItem] // export modules at top level
                 else [modItem]
-            let modItems = com.GetAllModules() |> List.sortBy fst |> List.collect makeModItems
+            let modItems =
+                com.GetAllModules()
+                |> List.sortBy fst
+                |> List.collect makeModItems
             modItems
         else []
 
@@ -2709,14 +2714,14 @@ module Util =
         | Some path ->
             // add some imports for main
             let asStr = getLibraryImportName com ctx "String" "string"
-            let asArr = getLibraryImportName com ctx "Native" "arrayFrom"
+            let asArr = getLibraryImportName com ctx "Native" "array"
 
             // main entrypoint
             let mainName = String.concat "::" path
             let strBody = [
                 $"let args: Vec<String> = std::env::args().collect()"
                 $"let args: Vec<Rc<str>> = args[1..].iter().map(|s| {asStr}(s)).collect()"
-                $"{mainName}({asArr}(&args))"
+                $"{mainName}({asArr}(args))"
             ]
             let fnBody = strBody |> Seq.map mkEmitSemiStmt |> mkBlock |> Some
 
@@ -3643,14 +3648,18 @@ module Util =
 
         match decl with
         | Fable.ModuleDeclaration decl ->
-            // TODO: perhaps collect other use decls from usage in body
-            let useItem = mkGlobUseItem [] ["super"]
-            let useDecls = [useItem]
             let memberDecls = decl.Members |> List.collect (transformDecl com ctx)
-            let attrs =  []
-            let modDecls = useDecls @ memberDecls
-            let modItem = modDecls |> mkModItem attrs decl.Name
-            [modItem |> mkPublicItem]
+            if List.isEmpty memberDecls then
+                [] // don't output empty modules
+            else
+                // TODO: perhaps collect other use decls from usage in body
+                let useItem = mkGlobUseItem [] ["super"]
+                let useDecls = [useItem]
+                let attrs =  []
+                let modDecls = useDecls @ memberDecls
+                let modItem = modDecls |> mkModItem attrs decl.Name
+                [modItem |> mkPublicItem]
+
 
         | Fable.ActionDeclaration decl ->
             // TODO: use ItemKind.Static with IIFE closure?
@@ -3668,34 +3677,50 @@ module Util =
         | Fable.ClassDeclaration decl ->
             transformClassDecl com ctx decl
 
-    let getImportFullPath (com: IRustCompiler) (path: string) =
-        let isAbsolutePath =
-            path.StartsWith("/") || path.StartsWith("\\") || path.IndexOf(":") = 1
-        let isLibraryPath =
-            path.StartsWith(com.LibraryDir)
-        if isAbsolutePath || isLibraryPath then
-            Fable.Path.normalizePath path
-        else
-            let currentDir = Fable.Path.GetDirectoryName(com.CurrentFile)
-            Fable.Path.Combine(currentDir, path)
-            |> Fable.Path.normalizeFullPath
+    // F# hash function is unstable and gives different results in different runs
+    // Taken from fable-library/Util.ts. Possible variant in https://stackoverflow.com/a/1660613
+    let stableStringHash (s: string) =
+        let mutable h = 5381
+        for i = 0 to s.Length - 1 do
+            h <- (h * 33) ^^^ (int s.[i])
+        h
 
     let isFableLibrary (com: IRustCompiler) =
         List.contains "FABLE_LIBRARY" com.Options.Define //TODO: look in project defines too
 
-    let isFableLibraryImport (com: IRustCompiler) (path: string) =
-        not (isFableLibrary com) && path.StartsWith(com.LibraryDir)
+    let isFableLibraryPath (com: IRustCompiler) (path: string) =
+        not (isFableLibrary com) && (path.StartsWith(com.LibraryDir) || path = "fable_library_rust")
+
+    let getImportModulePath (com: IRustCompiler) (path: string) =
+        let isAbsolutePath =
+            path.StartsWith("/") || path.StartsWith("\\") || path.IndexOf(":") = 1
+        let modulePath =
+            if isAbsolutePath || (isFableLibraryPath com path) then
+                Fable.Path.normalizePath path
+            else
+                let currentDir = Fable.Path.GetDirectoryName(com.CurrentFile)
+                Fable.Path.Combine(currentDir, path)
+                |> Fable.Path.normalizeFullPath
+        modulePath
+
+    let getImportModuleName (com: IRustCompiler) (modulePath: string) =
+        System.String.Format("module_{0:x}", stableStringHash modulePath)
 
     let transformImports (com: IRustCompiler) ctx (imports: Import list): Rust.Item list =
         imports
-        |> List.groupBy (fun import -> import.FullPath)
-        |> List.collect (fun (_fullPath, moduleImports) ->
+        |> List.groupBy (fun import -> import.ModulePath)
+        |> List.sortBy (fun (modulePath, _) -> modulePath)
+        |> List.collect (fun (_modulePath, moduleImports) ->
             moduleImports
+            |> List.sortBy (fun import -> import.Selector)
             |> List.map (fun import ->
                 let modPath =
-                    if isFableLibraryImport com import.Path
-                    then ["fable_library_rust"]
-                    else ["crate"; import.ModuleName]
+                    if import.Path.Length = 0
+                    then [] // empty path, means direct import of the selector
+                    else
+                        if isFableLibraryPath com import.Path
+                        then ["fable_library_rust"]
+                        else ["crate"; import.ModuleName]
                 match import.Selector with
                 | "" | "*" | "default" ->
                     mkGlobUseItem [] modPath
@@ -3715,24 +3740,13 @@ module Util =
         | _ -> splitFullName selector |> List.last
         |> getUniqueNameInRootScope ctx
 
-    // F# hash function is unstable and gives different results in different runs
-    // Taken from fable-library/Util.ts. Possible variant in https://stackoverflow.com/a/1660613
-    let stableStringHash (s: string) =
-        let mutable h = 5381
-        for i = 0 to s.Length - 1 do
-            h <- (h * 33) ^^^ (int s.[i])
-        h
-
-    let getModuleName fullPath =
-        System.String.Format("module_{0:x}", stableStringHash fullPath)
-
 
 module Compiler =
     open System.Collections.Generic
     open System.Collections.Concurrent
     open Util
 
-    // global level (across files)
+    // global list of import modules (across files)
     let importModules = ConcurrentDictionary<string, string>()
 
     // per file
@@ -3745,42 +3759,42 @@ module Compiler =
                 if onlyOnceWarnings.Add(msg) then
                     addWarning com [] range msg
 
-            member this.GetImportName(ctx, selector, path, r) =
+            member self.GetImportName(ctx, selector, path, r) =
                 if selector = Fable.Naming.placeholder then
                     "`importMember` must be assigned to a variable"
                     |> addError com [] r
                 let path = path |> Fable.Naming.replaceSuffix ".fs" ".rs"
-                if path.Contains("::") then
-                    path + "::" + selector // direct Rust import
-                else
-                    let cacheKey = path + "::" + selector
-                    let import =
-                        match imports.TryGetValue(cacheKey) with
-                        | true, import -> import
-                        | false, _ ->
-                            let fullPath = getImportFullPath this path
-                            let localIdent = getIdentForImport ctx path selector
-                            let moduleName = getModuleName fullPath
-                            let import = {
-                                Selector = selector
-                                LocalIdent = localIdent
-                                ModuleName = moduleName
-                                FullPath = fullPath
-                                Path = path
-                            }
-                            if not (isFableLibraryImport this path) then
-                                importModules.TryAdd(fullPath, moduleName) |> ignore
-                            imports.Add(cacheKey, import)
-                            import
-                    $"{import.LocalIdent}"
+                let cacheKey =
+                    if (isFableLibraryPath self path)
+                    then "fable_library_rust::" + selector
+                    elif path.Length = 0 then selector
+                    else path + "::" + selector
+                let import =
+                    match imports.TryGetValue(cacheKey) with
+                    | true, import -> import
+                    | false, _ ->
+                        let localIdent = getIdentForImport ctx path selector
+                        let modulePath = getImportModulePath self path
+                        let moduleName = getImportModuleName self modulePath
+                        let import = {
+                            Selector = selector
+                            LocalIdent = localIdent
+                            ModuleName = moduleName
+                            ModulePath = modulePath
+                            Path = path
+                        }
+                        // add import module to a global list (across files)
+                        if path.Length > 0 && not (isFableLibraryPath self path) then
+                            importModules.TryAdd(modulePath, moduleName) |> ignore
+
+                        imports.Add(cacheKey, import)
+                        import
+                $"{import.LocalIdent}"
 
             member _.GetAllImports() = imports.Values |> Seq.toList
             member _.GetAllModules() = importModules |> Seq.map (fun p -> p.Key, p.Value) |> Seq.toList
 
-            member this.TransformAsExpr(ctx, e) = transformAsExpr this ctx e
-            // member this.TransformAsStatements(ctx, ret, e) = transformAsStatements this ctx ret e
-            // member this.TransformFunction(ctx, name, args, body) = transformFunction this ctx name args body
-            // member this.TransformImport(ctx, selector, path) = transformImport this ctx None selector path
+            member self.TransformAsExpr(ctx, e) = transformAsExpr self ctx e
 
             member _.GetEntity(fullName) =
                 match com.TryGetEntity(fullName) with

src/Fable.Transforms/Rust/Replacements.fs

@@ -818,6 +818,16 @@ let fableCoreLib (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisArg: Exp
             | _, [RequireStringConst com ctx r selector; RequireStringConst com ctx r path] -> makeImportUserGenerated r t selector path |> Some
             | _ -> None
         | _ -> None
+    | "Fable.Core.Rust", _ ->
+        match i.CompiledName, args with
+        | "import", [RequireStringConst com ctx r selector; RequireStringConst com ctx r path] ->
+            makeImportUserGenerated r t selector path |> Some
+        | "importAll", [RequireStringConst com ctx r path] ->
+            makeImportUserGenerated r t "*" path |> Some
+        | "emitExpr", [args; RequireStringConst com ctx r macro] ->
+            let args = destructureTupleArgs [args]
+            emitExpr r t args macro |> Some
+        | _ -> None
     | _ -> None
 
 let refCells (com: ICompiler) (ctx: Context) r t (i: CallInfo) (thisArg: Expr option) (args: Expr list) =

src/Fable.Transforms/Transforms.Util.fs

@@ -29,7 +29,7 @@ module Atts =
     let [<Literal>] inject = "Fable.Core.InjectAttribute" // typeof<Fable.Core.InjectAttribute>.FullName
     let [<Literal>] paramList = "Fable.Core.ParamListAttribute"// typeof<Fable.Core.ParamListAttribute>.FullName
     let [<Literal>] paramObject = "Fable.Core.ParamObjectAttribute"// typeof<Fable.Core.ParamObjectAttribute>.FullName
-    let [<Literal>] refType = "Fable.Core.Rust.ReferenceTypeAttribute" // typeof<Fable.Core.PointerTypeAttribute>.FullName
+    let [<Literal>] referenceType = "Fable.Core.Rust.ReferenceTypeAttribute" // typeof<Fable.Core.PointerTypeAttribute>.FullName
     let [<Literal>] jsDecorator = "Fable.Core.JS.DecoratorAttribute" // typeof<Fable.Core.JS.DecoratorAttribute>.FullName
     let [<Literal>] jsReflectedDecorator = "Fable.Core.JS.ReflectedDecoratorAttribute" // typeof<Fable.Core.JS.ReflectedDecoratorAttribute>.FullName
     let [<Literal>] jsxComponent = "Fable.Core.JSX.ComponentAttribute" // typeof<Fable.Core.JSX.ComponentAttribute>.FullName

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

@@ -72,15 +72,14 @@ pub mod Native_ {
         mkRefMut(x)
     }
 
-    #[inline]
-    pub fn array<T: Clone>(v: Vec<T>) -> Array<T> {
-        mkRefMut(v)
-    }
-
     // -----------------------------------------------------------
     // Arrays
     // -----------------------------------------------------------
 
+    pub fn array<T: Clone>(v: Vec<T>) -> Array<T> {
+        mkRefMut(v)
+    }
+
     pub fn arrayEmpty<T: Clone>() -> Array<T> {
         array(Vec::new())
     }

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

@@ -91,7 +91,7 @@ pub mod String_ {
         string(s.trim_matches(c))
     }
 
-    pub fn trimChars(s: string, a: Array<char> ) -> string {
+    pub fn trimChars(s: string, a: Array<char>) -> string {
         string(s.trim_matches(a.as_slice()))
     }
 
@@ -103,7 +103,7 @@ pub mod String_ {
         string(s.trim_end_matches(c))
     }
 
-    pub fn trimEndChars(s: string, a: Array<char> ) -> string {
+    pub fn trimEndChars(s: string, a: Array<char>) -> string {
         string(s.trim_end_matches(a.as_slice()))
     }
 
@@ -115,7 +115,7 @@ pub mod String_ {
         string(s.trim_start_matches(c))
     }
 
-    pub fn trimStartChars(s: string, a: Array<char> ) -> string {
+    pub fn trimStartChars(s: string, a: Array<char>) -> string {
         string(s.trim_start_matches(a.as_slice()))
     }
 
@@ -165,7 +165,6 @@ pub mod String_ {
         string(&[left.as_ref(), right.as_ref()].concat())
     }
 
-
     fn toIndex(offset: i32, opt: Option<(&str, &str)>) -> i32 {
         match opt {
             Some((s, _)) => offset + s.chars().count() as i32,

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

@@ -1,4 +1,11 @@
 module Fable_Library_Rust
 
-//this is currently needed because nothing in Async is directly referenced by the library.
-let placeholderAsync:unit = Fable.Core.JsInterop.importAll "./Async.rs"
+open Fable.Core.Rust
+
+// import helper that imports but doesn't emit anything except ()
+let inline private importAll path = emitExpr (importAll path) "()"
+
+// import native modules (not referenced elsewhere)
+let imports(): unit =
+    importAll "./Async.rs"
+    importAll "./Func.rs"

tests/Rust/tests/src/AsyncTests.fs

@@ -49,7 +49,7 @@ let shouldConvertTaskToASyncAndEvalCorrectly () =
 //     let t = Async.StartAsTask comp
 //     t.Result |> equal 5
 
-[<Fable.Core.Rust.ReferenceType(Fable.Core.Rust.RefType.Arc)>]
+[<Fable.Core.Rust.ReferenceType(Fable.Core.Rust.PointerType.Arc)>]
 type ArcRecord = {
     A: int
 }

tests/Rust/tests/src/RecordTests.fs

@@ -146,7 +146,7 @@ let ``Records with ref-type interior mutability`` () =
     x.MutRefValue <- x.MutRefValue + "c"
     x.MutRefValue |> equal "abc"
 
-[<Fable.Core.Rust.ReferenceType(Fable.Core.Rust.RefType.Arc)>]
+[<Fable.Core.Rust.ReferenceType(Fable.Core.Rust.PointerType.Arc)>]
 type ArcRecord = {
     a: int
     b: string