Start spec'ing out the GoValueFormatter

Author: amckinney

generators/go-v2/ast/src/context/AbstractGoGeneratorContext.ts

@@ -106,6 +106,105 @@ export abstract class AbstractGoGeneratorContext<
         return undefined;
     }
 
+    public maybeUnwrapIterable(typeReference: TypeReference): TypeReference | undefined {
+        switch (typeReference.type) {
+            case "container":
+                const container = typeReference.container;
+                switch (container.type) {
+                    case "list":
+                        return container.list;
+                    case "set":
+                        return container.set;
+                    case "optional":
+                        return this.maybeUnwrapIterable(container.optional);
+                    case "nullable":
+                        return this.maybeUnwrapIterable(container.nullable);
+                    case "literal":
+                    case "map":
+                        return undefined;
+                    default:
+                        assertNever(container);
+                }
+            case "named":
+                const typeDeclaration = this.getTypeDeclarationOrThrow(typeReference.typeId).shape;
+                switch (typeDeclaration.type) {
+                    case "alias":
+                        return this.maybeUnwrapIterable(typeDeclaration.aliasOf);
+                    case "enum":
+                    case "object":
+                    case "union":
+                    case "undiscriminatedUnion":
+                        return undefined;
+                    default:
+                        assertNever(typeDeclaration);
+                }
+            case "primitive":
+            case "unknown":
+                return undefined;
+            default:
+                assertNever(typeReference);
+        }
+    }
+
+    public maybeUnwrapOptionalOrNullable(typeReference: TypeReference): TypeReference | undefined {
+        switch (typeReference.type) {
+            case "container":
+                const container = typeReference.container;
+                switch (container.type) {
+                    case "optional":
+                        return container.optional;
+                    case "nullable":
+                        return container.nullable;
+                    case "list":
+                    case "set":
+                    case "literal":
+                    case "map":
+                        return undefined;
+                    default:
+                        assertNever(container);
+                }
+            case "named":
+            case "primitive":
+            case "unknown":
+                return undefined;
+            default:
+                assertNever(typeReference);
+        }
+    }
+
+    /**
+     * Returns true if the type reference needs to be dereferenced to get the
+     * underlying type.
+     *
+     * Container types like lists, maps, and sets are already nil-able, so they
+     * don't require a dereference prefix.
+     */
+    public needsOptionalDereference(typeReference: TypeReference): boolean {
+        switch (typeReference.type) {
+            case "named":
+                const typeDeclaration = this.getTypeDeclarationOrThrow(typeReference.typeId).shape;
+                switch (typeDeclaration.type) {
+                    case "alias":
+                        return this.needsOptionalDereference(typeDeclaration.aliasOf);
+                    case "enum":
+                        return true;
+                    case "object":
+                    case "union":
+                    case "undiscriminatedUnion":
+                        return false;
+                    default:
+                        assertNever(typeDeclaration);
+                }
+            case "primitive":
+                return true;
+            case "container":
+            case "unknown":
+                return false;
+            default:
+                assertNever(typeReference);
+        }
+    }
+
     public getLiteralAsString(literal: Literal): string {
         return literal.type === "string" ? `'${literal.string}'` : literal.boolean ? "'true'" : "'false'";
     }

generators/go-v2/ast/src/context/GoValueFormatter.ts

@@ -0,0 +1,60 @@
+import { assertNever } from "@fern-api/core-utils";
+
+import { ContainerType, Literal, PrimitiveType, PrimitiveTypeV1, TypeReference } from "@fern-fern/ir-sdk/api";
+
+import { go } from "../";
+import { TypeInstantiation } from "../ast";
+import { BaseGoCustomConfigSchema } from "../custom-config/BaseGoCustomConfigSchema";
+import { AbstractGoGeneratorContext } from "./AbstractGoGeneratorContext";
+
+export declare namespace GoValueFormatter {
+    interface Args {
+        reference: TypeReference;
+        value: go.AstNode;
+    }
+
+    interface Result {
+        formatted: go.AstNode;
+        zeroValue: go.AstNode;
+        prefix: string;
+        suffix: string;
+        isIterable: boolean;
+        isOptional: boolean;
+        isPrimitive: boolean;
+    }
+}
+
+export class GoValueFormatter {
+    private context: AbstractGoGeneratorContext<BaseGoCustomConfigSchema>;
+
+    constructor(context: AbstractGoGeneratorContext<BaseGoCustomConfigSchema>) {
+        this.context = context;
+    }
+
+    public convert({ reference, value }: GoValueFormatter.Args): GoValueFormatter.Result {
+        const iterableType = this.context.maybeUnwrapIterable(reference);
+        if (iterableType != null) {
+            const format = this.convert({ reference: iterableType, value });
+            return {
+                ...format,
+                isIterable: true
+            };
+        }
+
+        let prefix = "";
+        let suffix = "";
+        let isOptional = false;
+        let isPrimitive = false;
+
+        const optionalOrNullableType = this.context.maybeUnwrapOptionalOrNullable(reference);
+        if (optionalOrNullableType != null) {
+            if (this.context.needsOptionalDereference(optionalOrNullableType)) {
+                prefix = "*";
+            }
+            isOptional = true;
+        }
+
+        // TODO: Implement the rest of the logic.
+        return {} as any;
+    }
+}