Merge pull request #42 from edgarfgp/rework-class-widget

Rework Class Widget
edgarfgp · Jun 13, 2023 · fd8834d · fd8834d
2 parents ecd292a + 235aacc
commit fd8834d
Show file tree

Hide file tree

Showing 8 changed files with 645 additions and 58 deletions.
diff --git a/src/Fabulous.AST.Tests/TypeDefinitions/Class.fs b/src/Fabulous.AST.Tests/TypeDefinitions/Class.fs
@@ -73,7 +73,7 @@ type Person =
                 )
             )
 
-        AnonymousModule() { Class("Person", []) { EscapeHatch(memberNode) } }
+        AnonymousModule() { (Class("Person") { EscapeHatch(memberNode) }).implicitConstructorParameters([]) }
         |> produces
             """
 type Person () =
@@ -110,12 +110,16 @@ type Person () =
             )
 
         let param =
-            SimplePatNode(None, false, SingleTextNode("name", Range.Zero), None, Range.Zero)
+            [ "name"; "lastName"; "age" ]
+            |> List.map(fun n -> SimplePatNode(None, false, SingleTextNode(n, Range.Zero), None, Range.Zero))
 
-        AnonymousModule() { Class("Person", [ param ]) { EscapeHatch(memberNode) } }
+        AnonymousModule() {
+            (Class("Person") { EscapeHatch(memberNode) })
+                .implicitConstructorParameters(param)
+        }
         |> produces
             """
-type Person (name) =
+type Person (name, lastName, age) =
     member this.Name = name
 
 """
@@ -149,14 +153,26 @@ type Person (name) =
             )
 
         let param =
-            SimplePatNode(None, false, SingleTextNode("name", Range.Zero), Some(Type.FromString("string")), Range.Zero)
+            [ ("name", "string"); ("lastName", "string"); ("age", "int") ]
+            |> List.map(fun n ->
+                let isOpt = fst n = "age"
+
+                SimplePatNode(
+                    None,
+                    isOpt,
+                    SingleTextNode(fst n, Range.Zero),
+                    Some(Type.FromString($"{snd n}")),
+                    Range.Zero
+                ))
 
-        AnonymousModule() { Class("Person", [ param ]) { EscapeHatch(memberNode) } }
+        AnonymousModule() {
+            (Class("Person") { EscapeHatch(memberNode) })
+                .implicitConstructorParameters(param)
+        }
         |> produces
             """
-type Person (name: string) =
+type Person (name: string, lastName: string, ?age: int) =
     member this.Name = name
-
 """
 
     [<Test>]
@@ -190,7 +206,11 @@ type Person (name: string) =
         let param =
             SimplePatNode(None, false, SingleTextNode("name", Range.Zero), Some(Type.FromString("string")), Range.Zero)
 
-        AnonymousModule() { (Class("Person", [ param ]) { EscapeHatch(memberNode) }).isStruct() }
+        AnonymousModule() {
+            (Class("Person") { EscapeHatch(memberNode) })
+                .isStruct()
+                .implicitConstructorParameters([ param ])
+        }
         |> produces
             """
 [<Struct>]
@@ -228,8 +248,9 @@ type Person (name: string) =
             )
 
         AnonymousModule() {
-            (Class("Person", []) { EscapeHatch(memberNode) })
+            (Class("Person") { EscapeHatch(memberNode) })
                 .attributes([ "Sealed"; "AbstractClass" ])
+                .implicitConstructorParameters([])
         }
         |> produces
             """
@@ -238,3 +259,179 @@ type Person () =
     member this.Name = ""
 
 """
+
+    [<Test>]
+    let ``Produces a generic class`` () =
+        let memberNode =
+            MemberDefn.Member(
+                BindingNode(
+                    None,
+                    None,
+                    MultipleTextsNode([ SingleTextNode("member", Range.Zero) ], Range.Zero),
+                    false,
+                    None,
+                    None,
+                    Choice1Of2(
+                        IdentListNode(
+                            [ IdentifierOrDot.Ident(SingleTextNode("this", Range.Zero))
+                              IdentifierOrDot.Ident(SingleTextNode(".", Range.Zero))
+                              IdentifierOrDot.Ident(SingleTextNode("Name", Range.Zero)) ],
+                            Range.Zero
+                        )
+                    ),
+                    None,
+                    List.Empty,
+                    None,
+                    SingleTextNode("=", Range.Zero),
+                    Expr.Constant(Constant.FromText(SingleTextNode("\"\"", Range.Zero))),
+                    Range.Zero
+                )
+            )
+
+        AnonymousModule() {
+            GenericClass("Person", [ "'a"; "'b" ]) { EscapeHatch(memberNode) }
+
+        }
+        |> produces
+            """
+type Person <'a, 'b> =
+    member this.Name = ""
+
+"""
+
+    [<Test>]
+    let ``Produces a generic class with a constructor`` () =
+        let memberNode =
+            MemberDefn.Member(
+                BindingNode(
+                    None,
+                    None,
+                    MultipleTextsNode([ SingleTextNode("member", Range.Zero) ], Range.Zero),
+                    false,
+                    None,
+                    None,
+                    Choice1Of2(
+                        IdentListNode(
+                            [ IdentifierOrDot.Ident(SingleTextNode("this", Range.Zero))
+                              IdentifierOrDot.Ident(SingleTextNode(".", Range.Zero))
+                              IdentifierOrDot.Ident(SingleTextNode("Name", Range.Zero)) ],
+                            Range.Zero
+                        )
+                    ),
+                    None,
+                    List.Empty,
+                    None,
+                    SingleTextNode("=", Range.Zero),
+                    Expr.Constant(Constant.FromText(SingleTextNode("\"\"", Range.Zero))),
+                    Range.Zero
+                )
+            )
+
+        AnonymousModule() {
+            (GenericClass("Person", [ "'a"; "'b" ]) { EscapeHatch(memberNode) })
+                .implicitConstructorParameters([])
+
+        }
+        |> produces
+            """
+type Person <'a, 'b>() =
+    member this.Name = ""
+
+"""
+
+    [<Test>]
+    let ``Produces a struct generic class with a constructor`` () =
+        let memberNode =
+            MemberDefn.Member(
+                BindingNode(
+                    None,
+                    None,
+                    MultipleTextsNode([ SingleTextNode("member", Range.Zero) ], Range.Zero),
+                    false,
+                    None,
+                    None,
+                    Choice1Of2(
+                        IdentListNode(
+                            [ IdentifierOrDot.Ident(SingleTextNode("this", Range.Zero))
+                              IdentifierOrDot.Ident(SingleTextNode(".", Range.Zero))
+                              IdentifierOrDot.Ident(SingleTextNode("Name", Range.Zero)) ],
+                            Range.Zero
+                        )
+                    ),
+                    None,
+                    List.Empty,
+                    None,
+                    SingleTextNode("=", Range.Zero),
+                    Expr.Constant(Constant.FromText(SingleTextNode("\"\"", Range.Zero))),
+                    Range.Zero
+                )
+            )
+
+        AnonymousModule() {
+            (GenericClass("Person", [ "'a"; "'b" ]) { EscapeHatch(memberNode) })
+                .isStruct()
+                .implicitConstructorParameters([])
+
+        }
+        |> produces
+            """
+[<Struct>]
+type Person <'a, 'b>() =
+    member this.Name = ""
+
+"""
+
+    [<Test>]
+    let ``Produces a class end`` () =
+        AnonymousModule() { ClassEnd("MyClass") }
+        |> produces
+            """
+type MyClass =
+    class
+    end
+            """
+
+    [<Test>]
+    let ``Produces a class end with constructor`` () =
+        AnonymousModule() { ClassEnd("MyClass").implicitConstructorParameters([]) }
+        |> produces
+            """
+type MyClass () =
+    class
+    end
+            """
+
+    [<Test>]
+    let ``Produces a class end with constructor and attributes`` () =
+        AnonymousModule() {
+            ClassEnd("MyClass")
+                .attributes([ "Sealed"; "AbstractClass" ])
+                .implicitConstructorParameters([])
+        }
+        |> produces
+            """
+[<Sealed; AbstractClass>]
+type MyClass () =
+    class
+    end
+            """
+
+    [<Test>]
+    let ``Produces a class end with type params`` () =
+        AnonymousModule() { ClassEnd("MyClass", [ "'a"; "'b" ]) }
+        |> produces
+            """
+type MyClass <'a, 'b> =
+    class
+    end
+            """
+
+    [<Test>]
+    let ``Produces a class end with constructor and  type params`` () =
+        AnonymousModule() { ClassEnd("MyClass", [ "'a"; "'b" ]).implicitConstructorParameters([]) }
+        |> produces
+            """
+type MyClass <'a, 'b>() =
+    class
+    end
+            """
diff --git a/src/Fabulous.AST/Fabulous.AST.fsproj b/src/Fabulous.AST/Fabulous.AST.fsproj
@@ -58,8 +58,10 @@
         <Compile Include="Widgets\TypeDefinitions\Abbrev.fs" />
         <Compile Include="Widgets\TypeDefinitions\Union.fs" />
         <Compile Include="Widgets\TypeDefinitions\Record.fs" />
-        <Compile Include="Widgets\TypeDefinitions\Class.fs" />
         <Compile Include="Widgets\TypeDefinitions\Interface.fs" />
+        <Compile Include="Widgets\TypeDefinitions\Class.fs" />
+        <Compile Include="Widgets\TypeDefinitions\GenericClass.fs" />
+        <Compile Include="Widgets\TypeDefinitions\ClassEnd.fs" />
         <Compile Include="Widgets\TypeDefinitions\GenericInterface.fs" />
         <Compile Include="Widgets\ControlFlow\IfThen.fs" />
         <Compile Include="Widgets\ControlFlow\IfThenElif.fs" />

diff --git a/src/Fabulous.AST/Widgets/Common.fs b/src/Fabulous.AST/Widgets/Common.fs
@@ -18,12 +18,19 @@ module Auxiliary =
         let lessThan = SingleTextNode.Create "<"
         let greaterThan = SingleTextNode.Create ">"
         let equals = SingleTextNode.Create "="
+        let comma = SingleTextNode.Create ","
         let ``type`` = SingleTextNode.Create "type"
         let leftAttribute = SingleTextNode.Create "[<"
         let rightAttribute = SingleTextNode.Create ">]"
         let leftCurlyBrace = SingleTextNode.Create "{"
         let rightCurlyBrace = SingleTextNode.Create "}"
+        let leftParenthesis = SingleTextNode.Create "("
+        let rightParenthesis = SingleTextNode.Create ")"
         let ``abstract`` = SingleTextNode.Create "abstract"
+        let ``interface`` = SingleTextNode.Create "interface"
+        let ``class`` = SingleTextNode.Create "class"
+        let ``end`` = SingleTextNode.Create "end"
+        let ``with`` = SingleTextNode.Create "with"
         let ``member`` = SingleTextNode.Create "member"
         let rightArrow = SingleTextNode.Create "->"
         let lefArrow = SingleTextNode.Create "<-"