Comment updates

generators/swift/codegen/src/ast/Comment.ts

@@ -0,0 +1,29 @@
+import { AstNode, Writer } from "@fern-api/generator-commons";
+import Swift from "..";
+
+export declare namespace Comment {
+  interface Args {
+    comment: string;
+  }
+}
+
+export class Comment extends AstNode {
+
+  public readonly comment: string;
+
+  constructor(args: Comment.Args) {
+    super(Swift.indentSize);
+    this.comment = args.comment;
+  }
+
+  private buildComment(comment: string): string {
+    const lines = comment.split("\n");
+    const formattedLines = lines.map(line => `/// ${line}`).join("\n");
+    return formattedLines;
+  }
+
+  public write(writer: Writer): void {
+    writer.write(this.buildComment(this.comment));
+  }
+
+}

generators/swift/codegen/src/ast/EnumCase.ts

@@ -25,7 +25,8 @@ export class EnumCase extends AstNode {
     public write(writer: Writer): void {
 
         if (this.comment) {
-            writer.write(`/// ${this.comment}`);
+            writer.newLine();
+            writer.writeNode(Swift.makeComment({ comment: this.comment }));
         }
 
         const statement = this.value ? `case ${this.name} = ${this.value}` : `case ${this.name}`;

generators/swift/codegen/src/ast/Field.ts

@@ -1,41 +1,40 @@
 import { AstNode, Writer } from "@fern-api/generator-commons";
 import Swift, { AccessLevel, SwiftClass } from "..";
+import { Optional } from "./Optional";
 import { VariableType } from "./VariableType";
 
 export declare namespace Field {
     interface Args {
+        comment?: string;
         accessLevel?: AccessLevel;
         variableType?: VariableType;
         name: string;
-        class: SwiftClass,
-        defaultValue?: string,
+        class: SwiftClass | Optional,
     }
 }
 
 export class Field extends AstNode {
+    public readonly comment?: string;
     public readonly accessLevel?: AccessLevel;
     public readonly variableType?: VariableType;
     public readonly name: string;
-    public readonly class: SwiftClass;
-    public readonly defaultValue?: string; // TODO
-
-    constructor({ 
-        accessLevel, 
-        variableType,
-        name,
-        class: valueType,
-        defaultValue,
-    }: Field.Args) {
+    public readonly class: SwiftClass | Optional;
+
+    constructor(args: Field.Args) {
         super(Swift.indentSize);
-        this.accessLevel = accessLevel;
-        this.variableType = variableType;
-        this.name = name;
-        this.class = valueType;
-        this.defaultValue = defaultValue;
+        this.comment = args.comment;
+        this.accessLevel = args.accessLevel;
+        this.variableType = args.variableType;
+        this.name = args.name;
+        this.class = args.class;
     }
 
     public write(writer: Writer): void {
 
+        if (this.comment) {
+            writer.writeNode(Swift.makeComment({ comment: this.comment }));
+        }
+
         // e.g. public static let name: String
         const title = [this.accessLevel, this.variableType ?? VariableType.Let, `${this.name}:`, this.class.name].join(" ");
         writer.write(title);

generators/swift/codegen/src/ast/Primative.ts

@@ -34,9 +34,7 @@ export class Primative extends SwiftClass {
     public readonly key?: PrimativeKey;
 
     constructor(args: Primative.Args) {
-        super({ 
-            name: Primative.getNameForKey(args.key)
-        });
+        super({ name: Primative.getNameForKey(args.key) });
         this.key = args.key;
     }
 

generators/swift/codegen/src/ast/Struct.ts

@@ -1,5 +1,6 @@
 import { AstNode, Writer } from "@fern-api/generator-commons";
 import Swift, { AccessLevel, Enum, Field, SwiftClass } from "..";
+import { Optional } from "./Optional";
 
 /*
 
@@ -22,6 +23,8 @@ Breakdown:
 
 export declare namespace Struct {
     interface Args {
+        /* Comment that appear above the class */
+        comment?: string;
         /* The access level of the type */
         accessLevel?: AccessLevel;
         /* The name of the struct */
@@ -32,26 +35,32 @@ export declare namespace Struct {
         subclasses?: (Enum | SwiftClass)[];
         /* The field variables in the class */
         fields?: Field[];
+        /* Build initializer */
+        addInitializer?: boolean;
     }
 }
 
 export class Struct extends AstNode {
+    public readonly comment?: string;
     public readonly accessLevel?: AccessLevel;
     public readonly name: string;
     public readonly fields?: Field[];
     public readonly inheritance?: SwiftClass[];
     public readonly subclasses?: (Enum | SwiftClass)[];
+    public readonly addInitializer: boolean;
 
     constructor(args: Struct.Args) {
         super(Swift.indentSize);
+        this.comment = args.comment;
         this.accessLevel = args.accessLevel;
         this.name = args.name;
         this.inheritance = args.inheritance;
         this.subclasses = args.subclasses;
         this.fields = args.fields;
+        this.addInitializer = args.addInitializer ?? false;
     }
 
-    private buildTitle(): string | undefined {
+    private buildStructTitle(): string | undefined {
 
         if (!this.inheritance) {
             return this.name;
@@ -62,10 +71,21 @@ export class Struct extends AstNode {
 
     }
 
+    private buildInitalizerTitle(): string | undefined {
+
+        const args = this.fields?.map(obj => {
+            const arg = `${obj.name}: ${obj.class.name}`;
+            return obj.class instanceof Optional ? `${arg} = nil` : arg;
+        }).join(", ");
+
+        return `init(${args ?? ""})`;
+
+    }
+
     public write(writer: Writer): void {
 
         // example: public struct Name {
-        writer.openBlock([this.accessLevel, "struct", this.buildTitle()], "{", () => {
+        writer.openBlock([this.accessLevel, "struct", this.buildStructTitle()], "{", () => {
 
             if (this.subclasses) {
                 writer.newLine();
@@ -77,6 +97,7 @@ export class Struct extends AstNode {
 
             if (this.fields) {
                 this.fields.forEach(field => {
+                    if (field.comment) { writer.newLine(); }
                     writer.writeNode(field);
                 });
             }
@@ -85,6 +106,22 @@ export class Struct extends AstNode {
                 writer.newLine();
             }
 
+            if (this.addInitializer) {
+
+                if (this.comment) {
+                    writer.writeNode(Swift.makeComment({ comment: this.comment }));
+                }
+
+                writer.openBlock([this.accessLevel, this.buildInitalizerTitle()], "{", () => {
+                    this.fields?.forEach(field => {
+                        writer.write(`self.${field.name} = ${field.name}`);
+                    });
+                }, "}");
+
+                writer.newLine();
+
+            }
+
         }, "}");
 
     }

generators/swift/codegen/src/ast/SwiftDictionary.ts

@@ -0,0 +1,63 @@
+import { Writer } from "@fern-api/generator-commons";
+import { Enum, SwiftClass } from "..";
+
+/*
+
+Builds Swift Types (Classes, Structs, etc)
+==========================================
+
+Example:
+
+private class Mike: Person {
+
+    class Snowboard {
+        ...
+    }
+
+    func wave() {
+        print("👋")
+    }
+
+}
+
+Breakdown:
+
+{accessLevel} {classLevel} {name}: {inheritance} {
+
+    {subclasses}
+
+    {functions}
+
+}
+
+*/
+
+export declare namespace SwiftDictionary {
+    interface Args {
+        class: SwiftClass;
+        /* Key Type */
+        keyClass: SwiftClass | Enum;
+        /* Value Type */
+        valueClass: SwiftClass | Enum;
+        // TODO: Handle default value
+    }
+}
+
+export class SwiftDictionary extends SwiftClass {
+
+    constructor(args: SwiftDictionary.Args) {
+        super({
+          accessLevel: args.class.accessLevel,
+          name: `[${args.keyClass.name}: ${args.valueClass.name}]`,
+          subclasses: args.class.subclasses,
+          fields: args.class.fields,
+          functions: args.class.functions,
+          inheritance: args.class.inheritance,
+        });
+      }
+
+      public write(writer: Writer): void {
+        writer.writeNode(this);
+      }
+
+}

generators/swift/codegen/src/index.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-extraneous-class */
 // Swift Imports
 import { AccessLevel } from "./ast/AccessLevel";
+import { Comment } from "./ast/Comment";
 import { Enum } from "./ast/Enum";
 import { EnumCase } from "./ast/EnumCase";
 import { Field } from "./ast/Field";
@@ -14,10 +15,12 @@ import { Primative } from "./ast/Primative";
 import { Struct } from "./ast/Struct";
 import { SwiftArray } from "./ast/SwiftArray";
 import { SwiftClass } from "./ast/SwiftClass";
+import { SwiftDictionary } from "./ast/SwiftDictionary";
 import { TypeAlias } from "./ast/TypeAlias";
 
 // Swift Exports
 export { AccessLevel } from "./ast/AccessLevel";
+export { Comment } from "./ast/Comment";
 export { Enum } from "./ast/Enum";
 export { EnumCase } from "./ast/EnumCase";
 export { Field } from "./ast/Field";
@@ -33,6 +36,7 @@ export type { PrimativeKey } from "./ast/Primative";
 export { Struct } from "./ast/Struct";
 export { SwiftArray } from "./ast/SwiftArray";
 export { SwiftClass } from "./ast/SwiftClass";
+export { SwiftDictionary as SwiftMap } from "./ast/SwiftDictionary";
 export { VariableType } from "./ast/VariableType";
 export { SwiftFile } from "./project/SwiftFile";
 
@@ -52,6 +56,10 @@ export default class Swift {
     return new FileHeader(args);
   }
 
+  public static makeComment(args: Comment.Args): Comment {
+    return new Comment(args);
+  }
+
   public static makeTypeAlias(args: TypeAlias.Args): TypeAlias {
     return new TypeAlias(args);
   }
@@ -96,6 +104,10 @@ export default class Swift {
     return new SwiftArray(args);
   }
 
+  public static makeDictionary(args: SwiftDictionary.Args): SwiftDictionary {
+    return new SwiftDictionary(args);
+  }
+
   public static makeOptional(args: Optional.Args): Optional {
     return new Optional(args);
   }
@@ -240,14 +252,15 @@ export default class Swift {
        * 
        * }
        */
-      makeCodableStruct(props: { safeName: string, codingArgs: EnumCase.Args[], fields: Field[] }): File {
+      makeCodableStruct(props: {  safeName: string, codingArgs: EnumCase.Args[], fields: Field[], comment?: string }): File {
 
         return Swift.makeFile({
           fileHeader: Swift.factories.fileHeaders.makeHeaderWithFernStub(props.safeName),
           imports: [
             Swift.factories.imports.makeFoundation()
           ],
           node: Swift.makeStruct({
+            comment: props.comment,
             accessLevel: AccessLevel.Public,
             name: props.safeName,
             inheritance: [
@@ -257,6 +270,7 @@ export default class Swift {
               Swift.factories.enums.makeCodingKeys(props.codingArgs),
             ],
             fields: props.fields,
+            addInitializer: true,
           })
         });
       }