Undiscriminated Unions

generators/commons/src/AstNode.ts

@@ -15,7 +15,7 @@ export abstract class AstNode {
     /**
      * Writes the node to a string.
      */
-    public toString(): string {
+    public render(): string {
         const writer = new Writer(this.indentSize);
         this.write(writer);
         return writer.toString();

generators/commons/src/GeneratedFile.ts

@@ -4,13 +4,14 @@ import { join } from "path";
 import { AstNode } from "./AstNode";
 
 export class GeneratedFile {
+
     public name: string;
     public extension: string;
     public outputDirectory: string;
     public contents: AstNode;
 
-    get filename(): string {
-        return `${this.name}.${this.extension}`;
+    get filename(): string { 
+        return `${this.name}.${this.extension}`; 
     }
 
     constructor(fileName: string, fileExtension: string, outputDirectory: string, contents: AstNode) {
@@ -23,7 +24,7 @@ export class GeneratedFile {
     public async generate(): Promise<string> {
         await mkdir(this.outputDirectory, { recursive: true });
         const outputFile = `${this.outputDirectory}/${this.filename}`;
-        await writeFile(outputFile, this.contents.toString());
+        await writeFile(outputFile, this.contents.render());
         return outputFile;
     }
 
@@ -38,4 +39,5 @@ export class GeneratedFile {
             console.error(`Error reading file: ${error}`);
         }
     }
+
 }

generators/commons/src/Writer.ts

@@ -41,13 +41,13 @@ export class Writer {
         callback: () => void,
         closingCharacter: string | undefined = "}"
     ): void {
-        const filteredTitles = titles.filter((title) => title !== undefined).join(" ");
+        const filteredTitles = titles.filter(title => title !== undefined).join(" ");
         if (filteredTitles) {
             this.write(`${filteredTitles} ${openingCharacter ?? ""}`);
         } else {
             this.write(openingCharacter ?? "");
         }
-
+        
         try {
             this.indent(callback);
         } finally {
@@ -72,17 +72,8 @@ export class Writer {
         return this.buffer;
     }
 
-    private calculateIndentationDistance(example: string): number {
-        const trimmedExample = example.trim();
-        if (trimmedExample.length) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            return example.indexOf(trimmedExample[0]!);
-        }
-
-        return 0;
-    }
-
     private getIndentString(tabSize: number): string {
         return " ".repeat(this.indentLevel * tabSize);
     }
-}
+
+}

generators/commons/src/index.ts

@@ -8,3 +8,4 @@ export * from "./GeneratorNotificationService";
 export * from "./parseGeneratorConfig";
 export * from "./PersistedProject";
 export * from "./Writer";
+

generators/csharp/codegen/src/index.ts

@@ -5,3 +5,4 @@ export * as csharp from "./csharp";
 export { FileGenerator } from "./FileGenerator";
 export * from "./project";
 export { TestFileGenerator } from "./TestFileGenerator";
+

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

@@ -1,35 +1,35 @@
-/**
+    /**
  * An enum representing different access levels, similar to Swift's access control levels.
  * This enum can be used to define and check access permissions for various parts of a TypeScript application.
  */
 export enum AccessLevel {
-    /**
-     * Open: Accessible and subclassable/overridable outside the module.
-     * This is the highest (most permissive) access level.
-     */
-    Open = "open",
+  /**
+   * Open: Accessible and subclassable/overridable outside the module.
+   * This is the highest (most permissive) access level.
+   */
+  Open = "open",
 
-    /**
-     * Public: Accessible outside the module but not subclassable/overridable.
-     * Suitable for exposing an API to be used by other modules.
-     */
-    Public = "public",
+  /**
+   * Public: Accessible outside the module but not subclassable/overridable.
+   * Suitable for exposing an API to be used by other modules.
+   */
+  Public = "public",
 
-    /**
-     * Internal: Accessible within the same module.
-     * The default access level for most parts of a module’s internal implementation.
-     */
-    Internal = "internal",
+  /**
+   * Internal: Accessible within the same module.
+   * The default access level for most parts of a module’s internal implementation.
+   */
+  Internal = "internal",
 
-    /**
-     * Fileprivate: Accessible within the same file.
-     * Useful for encapsulating implementation details that are shared across multiple types within a file but should not be accessible from other files.
-     */
-    Fileprivate = "fileprivate",
+  /**
+   * Fileprivate: Accessible within the same file.
+   * Useful for encapsulating implementation details that are shared across multiple types within a file but should not be accessible from other files.
+   */
+  Fileprivate = "fileprivate",
 
-    /**
-     * Private: Accessible within the same enclosing declaration (class, struct, or extension) and their extensions within the same file.
-     * Used for tightly encapsulating implementation details.
-     */
-    Private = "private"
+  /**
+   * Private: Accessible within the same enclosing declaration (class, struct, or extension) and their extensions within the same file.
+   * Used for tightly encapsulating implementation details.
+   */
+  Private = "private"
 }

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/Enum.ts

@@ -1,51 +1,63 @@
 import { AstNode, Writer } from "@fern-api/generator-commons";
-import Swift, { AccessLevel, EnumCase, Type } from "..";
+import Swift, { AccessLevel, EnumCase, SwiftClass } from "..";
+import { EnumCaseAssociatedValue } from "./EnumCaseAssociatedValue";
 
 export declare namespace Enum {
     interface Args {
         accessLevel?: AccessLevel;
         name: string;
-        inheritance?: Type[];
-        enumCases: EnumCase[];
+        inheritance?: SwiftClass[],
+        enumCases: EnumCase[] | EnumCaseAssociatedValue[],
+        comment?: string,
     }
 }
 
 export class Enum extends AstNode {
+
     public readonly accessLevel?: AccessLevel;
     public readonly name: string;
-    public readonly inheritance?: Type[];
-    public readonly enumCases: EnumCase[];
+    public readonly inheritance?: SwiftClass[];
+    public readonly enumCases: EnumCase[] | EnumCaseAssociatedValue[];
+    public readonly comment?: string;
 
-    constructor({ accessLevel, name, inheritance, enumCases }: Enum.Args) {
+    constructor(args: Enum.Args) {
         super(Swift.indentSize);
-        this.accessLevel = accessLevel;
-        this.name = name;
-        this.inheritance = inheritance;
-        this.enumCases = enumCases;
+        this.accessLevel = args.accessLevel;
+        this.name = args.name;
+        this.inheritance = args.inheritance;
+        this.enumCases = args.enumCases;
+        this.comment = args.comment;
     }
 
     private buildTitle(): string | undefined {
+
         if (!this.inheritance) {
             return this.name;
         }
 
-        const names = this.inheritance.map((obj) => obj.name).join(", ");
+        const names = this.inheritance.map(obj => obj.name).join(", ");
         return `${this.name}: ${names}`;
+
     }
 
     public write(writer: Writer): void {
-        // example: enum CodingKeys: String, CodingKey {
-        writer.openBlock(
-            ["enum", this.buildTitle()],
-            "{",
-            () => {
-                if (this.enumCases) {
-                    this.enumCases.forEach((value) => {
-                        writer.writeNode(value);
-                    });
-                }
-            },
-            "}"
-        );
+
+        if (this.comment) {
+            writer.newLine();
+            writer.writeNode(Swift.makeComment({ comment: this.comment }));
+        }
+
+        // example: public enum CodingKeys: String, CodingKey {
+        writer.openBlock([this.accessLevel, "enum", this.buildTitle()], "{", () => {
+
+            if (this.enumCases) {
+                this.enumCases.forEach(value => {
+                    writer.writeNode(value);
+                });
+            }
+
+        }, "}");
+
     }
+
 }

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

@@ -4,22 +4,34 @@ import Swift from "..";
 export declare namespace EnumCase {
     interface Args {
         name: string;
-        key?: string;
+        value?: string;
+        comment?: string;
     }
 }
 
 export class EnumCase extends AstNode {
+
     public readonly name: string;
-    public readonly key?: string;
+    public readonly value?: string;
+    public readonly comment?: string;
 
-    constructor({ name, key }: EnumCase.Args) {
+    constructor(args: EnumCase.Args) {
         super(Swift.indentSize);
-        this.name = name;
-        this.key = key;
+        this.name = args.name;
+        this.value = args.value;
+        this.comment = args.comment;
     }
 
     public write(writer: Writer): void {
-        const statement = this.key ? `case ${this.name} = ${this.key}` : `case ${this.name}`;
+
+        if (this.comment) {
+            writer.newLine();
+            writer.writeNode(Swift.makeComment({ comment: this.comment }));
+        }
+
+        const statement = this.value ? `case ${this.name} = ${this.value}` : `case ${this.name}`;
         writer.write(statement);
+
     }
+
 }