feat: improve detection of StandardLibrary types like Promise, Boolean and add supports for RegExp via a type alias

[converter][web]

Author: MangelMaxime

src/Glutinum.Converter/Generate.fs

@@ -43,14 +43,6 @@ let generateBindingFile (filePath: string) =
     for reporter in transformResult.Errors do
         Log.error reporter
 
-    let outFile =
-        {
-            Name = "Glutinum"
-            Opens = [ "Fable.Core"; "Fable.Core.JsInterop"; "System" ]
-        }
-
-    Printer.printOutFile printer outFile
-
-    Printer.print printer transformResult.FSharpAST
+    Printer.printFile printer transformResult
 
     printer.ToString()

src/Glutinum.Converter/GlueAST.fs

@@ -229,6 +229,13 @@ type GlueTypeReference =
         Name: string
         FullName: string
         TypeArguments: GlueType list
+        // Should we replace that with a real computation of the FullName
+        // and use it to determine if it's from standard library?
+        // I think right now, we don't have a correct FullName because I didn't know how to get it
+        // but a few days ago, I found a way to access the source file information
+        // this is how the isStandardLibrary is determined
+        // so we can perhaps revisit the FullName reader logic with this new knowledge
+        IsStandardLibrary: bool
     }
 
 type GlueTypeUnion = GlueTypeUnion of GlueType list

src/Glutinum.Converter/Printer.fs

@@ -39,17 +39,6 @@ type Printer() =
 
     member __.ToStringWithoutTrailNewLine() = buffer.ToString().Trim()
 
-let printOutFile (printer: Printer) (outFile: FSharpOutFile) =
-    printer.Write($"module rec {outFile.Name}")
-    printer.NewLine
-    printer.NewLine
-
-    outFile.Opens
-    |> List.iter (fun o ->
-        printer.Write($"open {o}")
-        printer.NewLine
-    )
-
 module Naming =
     let (|Digit|_|) (digit: string) =
         if String.IsNullOrWhiteSpace digit then
@@ -280,18 +269,15 @@ and printType (fsharpType: FSharpType) =
         | FSharpPrimitive.Number -> "float"
         | FSharpPrimitive.Null -> "obj"
     | FSharpType.TypeReference typeReference ->
-        let replacedName =
-            Naming.mapTypeNameToFableCoreAwareName typeReference.Name
-
         if typeReference.TypeArguments.Length > 0 then
             let typeArguments =
                 typeReference.TypeArguments
                 |> List.map printType
                 |> String.concat ", "
 
-            $"{replacedName}<{typeArguments}>"
+            $"{typeReference.Name}<{typeArguments}>"
         else
-            replacedName
+            typeReference.Name
 
     | FSharpType.TypeParameter name -> $"'{name}"
     | FSharpType.Option optionType -> printType optionType + " option"
@@ -880,7 +866,7 @@ let private printTypeAlias (printer: Printer) (aliasInfo: FSharpTypeAlias) =
     printer.NewLine
     printer.Unindent
 
-let rec print (printer: Printer) (fsharpTypes: FSharpType list) =
+let rec private print (printer: Printer) (fsharpTypes: FSharpType list) =
     match fsharpTypes with
     | fsharpType :: tail ->
         printer.NewLine
@@ -957,3 +943,28 @@ let rec print (printer: Printer) (fsharpTypes: FSharpType list) =
         print printer tail
 
     | [] -> ()
+
+let printFile (printer: Printer) (transformResult: Transform.TransformResult) =
+
+    let outFile =
+        {
+            Name = "Glutinum"
+            Opens = [ "Fable.Core"; "Fable.Core.JsInterop"; "System" ]
+        }
+
+    printer.Write($"module rec {outFile.Name}")
+    printer.NewLine
+    printer.NewLine
+
+    outFile.Opens
+    |> List.iter (fun o ->
+        printer.Write($"open {o}")
+        printer.NewLine
+    )
+
+    if transformResult.IncludeRegExpAlias then
+        printer.NewLine
+        printer.Write "type RegExp = Text.RegularExpressions.Regex"
+        printer.NewLine
+
+    print printer transformResult.FSharpAST

src/Glutinum.Converter/Reader/TypeNode.fs

@@ -170,7 +170,7 @@ let readTypeNode
 
         let symbolOpt = checker.getSymbolAtLocation !!typeReferenceNode.typeName
 
-        let readTypeReference () =
+        let readTypeReference (isStandardLibrary: bool) =
             match symbolOpt.Value.flags with
             | HasSymbolFlags Ts.SymbolFlags.TypeParameter ->
                 symbolOpt.Value.name |> GlueType.TypeParameter
@@ -182,6 +182,7 @@ let readTypeNode
                             checker
                             (!!typeReferenceNode.typeName)
                     TypeArguments = readTypeArguments reader typeReferenceNode
+                    IsStandardLibrary = isStandardLibrary
                 })
                 |> GlueType.TypeReference
 
@@ -190,9 +191,9 @@ let readTypeNode
             | "Exclude" -> UtilityType.readExclude reader typeReferenceNode
             | "Partial" -> UtilityType.readPartial reader typeReferenceNode
             | "Record" -> UtilityType.readRecord reader typeReferenceNode
-            | _ -> readTypeReference ()
+            | _ -> readTypeReference true
         else
-            readTypeReference ()
+            readTypeReference false
 
     | Ts.SyntaxKind.ArrayType ->
         let arrayTypeNode = typeNode :?> Ts.ArrayTypeNode
@@ -362,6 +363,7 @@ let readTypeNode
             Name = expression.expression.getText () // Keep the double expression !!!
             FullName = getFullNameOrEmpty checker expression
             TypeArguments = readTypeArguments reader expression
+            IsStandardLibrary = false // TODO: Should we check if it's from the standard library?
         })
         |> GlueType.TypeReference
 

src/Glutinum.Converter/Reader/UnionTypeNode.fs

@@ -86,6 +86,7 @@ let rec private readUnionTypeCases
                         Name = typeReferenceNode.getText ()
                         FullName = fullName
                         TypeArguments = []
+                        IsStandardLibrary = isFromEs5Lib symbolOpt
                     })
                     |> GlueType.TypeReference
                     |> List.singleton

src/Glutinum.Converter/Transform.fs

@@ -13,6 +13,8 @@ type Reporter() =
 
     member val Errors = errors
 
+    member val HasRegEpx = false with get, set
+
 // Not really proud of this implementation, but I was not able to make it in a
 // pure functional way, using a Tree structure or something similar
 // It seems like for now this implementation does the job which is the most important
@@ -43,6 +45,15 @@ type TransformContext
     // You should not use this directly, but instead use the AddWarning and AddError methods
     member val _Reporter = reporter
 
+    member _.ExposeRegExp() =
+        // TODO: Rework how we memorize if need to expose RegExp alias
+        // Perhaps, before the printer phase we should traverse the whole AST to find information
+        // like aliases that we need to expose
+        // We could propagate the IsStandardLibrary flag to the F# AST to check such information
+        // Example: If we find an F# TypeReference with the name "RegExp" and the IsStandardLibrary flag is true
+        // then we need to expose the RegExp alias
+        reporter.HasRegEpx <- true
+
     member _.ExposeType(typ: FSharpType) =
         match parent with
         | None -> types.Add(typ)
@@ -99,6 +110,26 @@ type TransformContext
 
     member _.AddError(error: string) = reporter.Errors.Add error
 
+let private mapTypeNameToFableCoreAwareName
+    (context: TransformContext)
+    (typeReference: GlueTypeReference)
+    =
+
+    if typeReference.IsStandardLibrary then
+        match typeReference.Name with
+        | "Date" -> "JS.Date"
+        | "Promise" -> "JS.Promise"
+        | "Uint8Array" -> "JS.Uint8Array"
+        | "ReadonlyArray" -> "ResizeArray"
+        | "Array" -> "ResizeArray"
+        | "Boolean" -> "bool"
+        | "RegExp" ->
+            context.ExposeRegExp()
+            "RegExp"
+        | name -> name
+    else
+        typeReference.Name
+
 let private unwrapOptionIfAlreadyOptional
     (context: TransformContext)
     (typ: GlueType)
@@ -373,11 +404,15 @@ let rec private transformType
 
     | GlueType.TypeReference typeReference ->
         ({
-            Name = Naming.mapTypeNameToFableCoreAwareName typeReference.Name
+            Name = mapTypeNameToFableCoreAwareName context typeReference
             FullName = typeReference.FullName
             TypeArguments =
                 typeReference.TypeArguments |> List.map (transformType context)
             Type = //transformType context typeReference.TypeRef
+                // TODO: This code looks suspicious
+                // Why would a typeReference always be a string? I think I added that here to make
+                // the compiler happy because we don't have a concrete type for the TypeReference
+                // this is because of the recursive types which creates infinite loops in the reader
                 FSharpType.Primitive FSharpPrimitive.String
         }
         : FSharpTypeReference)
@@ -1827,7 +1862,8 @@ let private transformTypeAliasDeclaration
         |> FSharpType.TypeAlias
 
     | GlueType.TypeReference typeReference ->
-        let context = context.PushScope typeReference.Name
+        let mappedName = mapTypeNameToFableCoreAwareName context typeReference
+        let context = context.PushScope mappedName
 
         let handleDefaultCase () =
             ({
@@ -1884,7 +1920,7 @@ let private transformTypeAliasDeclaration
                     Name = typeAliasName
                     Type =
                         {
-                            Name = typeReference.Name
+                            Name = mappedName
                             FullName = typeReference.FullName
                             TypeArguments =
                                 [ FSharpType.Interface typeArgument ]
@@ -2197,11 +2233,20 @@ let private transform
         yield! rootTransformContext.ToList()
     ]
 
+type TransformResult =
+    {
+        FSharpAST: FSharpType list
+        Warnings: ResizeArray<string>
+        Errors: ResizeArray<string>
+        IncludeRegExpAlias: bool
+    }
+
 let apply (glueAst: GlueType list) =
     let reporter = Reporter()
 
-    {|
+    {
         FSharpAST = transform reporter true glueAst
         Warnings = reporter.Warnings
         Errors = reporter.Errors
-    |}
+        IncludeRegExpAlias = reporter.HasRegEpx
+    }

src/Glutinum.Converter/Utils/Naming.fs

@@ -20,16 +20,6 @@ let private escapeName (name: string) : string =
     else
         name
 
-let mapTypeNameToFableCoreAwareName (name: string) : string =
-    match name with
-    | "Date" -> "JS.Date"
-    | "Promise" -> "JS.Promise"
-    | "Uint8Array" -> "JS.Uint8Array"
-    | "ReadonlyArray" -> "ResizeArray"
-    | "Array" -> "ResizeArray"
-    | "Boolean" -> "bool"
-    | name -> name
-
 let removeSurroundingQuotes (text: string) : string =
     if String.IsNullOrEmpty text then
         ""

src/Glutinum.Web/Pages/Editors.FSharpCode.fs

@@ -80,20 +80,7 @@ let private generateFile
 
             let transformResult = Transform.apply readerResult.GlueAST
 
-            let outFile =
-                {
-                    Name = "Glutinum"
-                    Opens =
-                        [
-                            "Fable.Core"
-                            "Fable.Core.JsInterop"
-                            "System"
-                        ]
-                }
-
-            Printer.printOutFile printer outFile
-
-            Printer.print printer transformResult.FSharpAST
+            Printer.printFile printer transformResult
 
             CompilationResult.Success(
                 printer.ToString(),

src/Glutinum.Web/Pages/Editors.GlueAST.GlueASTViewer.fs

@@ -475,6 +475,9 @@ type GlueASTViewer =
                 [
                     GlueASTViewer.Name typeReference.Name
                     ASTViewer.renderKeyValue "FullName" typeReference.FullName
+                    ASTViewer.renderKeyValue
+                        "IsStandardLibrary"
+                        (string typeReference.IsStandardLibrary)
 
                     typeReference.TypeArguments
                     |> List.map GlueASTViewer.GlueType

tests/specs/references/intersectionType/insideOfTypeArguments.fsx

@@ -11,11 +11,11 @@ type RecordEntryObject =
     abstract member n: float with get, set
 
 type RecordEntryArrayItem =
-    ResizeArray<RecordEntryArrayItem.ReadonlyArray.ReturnType>
+    ResizeArray<RecordEntryArrayItem.ResizeArray.ReturnType>
 
 module RecordEntryArrayItem =
 
-    module ReadonlyArray =
+    module ResizeArray =
 
         [<AllowNullLiteral>]
         [<Interface>]

tests/specs/references/naming/Uint8Array.d.ts

@@ -0,0 +1 @@
+type T = Array<number>

tests/specs/references/naming/Uint8Array.fsx

@@ -0,0 +1,12 @@
+module rec Glutinum
+
+open Fable.Core
+open Fable.Core.JsInterop
+open System
+
+type T =
+    ResizeArray<float>
+
+(***)
+#r "nuget: Fable.Core"
+(***)

tests/specs/references/replacements/Array.d.ts

@@ -0,0 +1 @@
+type T = Boolean

tests/specs/references/replacements/Array.fsx

@@ -0,0 +1,12 @@
+module rec Glutinum
+
+open Fable.Core
+open Fable.Core.JsInterop
+open System
+
+type T =
+    bool
+
+(***)
+#r "nuget: Fable.Core"
+(***)

tests/specs/references/replacements/Boolean.d.ts

@@ -0,0 +1 @@
+type T = RegExp

tests/specs/references/replacements/Boolean.fsx

@@ -0,0 +1,14 @@
+module rec Glutinum
+
+open Fable.Core
+open Fable.Core.JsInterop
+open System
+
+type RegExp = Text.RegularExpressions.Regex
+
+type T =
+    RegExp
+
+(***)
+#r "nuget: Fable.Core"
+(***)

tests/specs/references/naming/promise.d.ts tests/specs/references/replacements/Promise.d.ts

@@ -0,0 +1 @@
+type T = Uint8Array