feat(go): [DRAFT] Add support for response headers

generators/go-v2/ast/src/ast/Func.ts

@@ -17,10 +17,6 @@ export class Func extends AstNode {
         this.func = new Method({ name, parameters, return_, body, docs });
     }
 
-    public get name(): string {
-        return this.func.name;
-    }
-
     public get parameters(): Parameter[] {
         return this.func.parameters;
     }
@@ -29,6 +25,10 @@ export class Func extends AstNode {
         return this.func.return_;
     }
 
+    public get name(): string | undefined {
+        return this.func.name;
+    }
+
     public get body(): CodeBlock | undefined {
         return this.func.body;
     }

generators/go-v2/ast/src/ast/FuncInvocation.ts

@@ -9,22 +9,26 @@ export declare namespace FuncInvocation {
         func: GoTypeReference;
         /* The arguments passed to the method */
         arguments_: AstNode[];
+        /* Whether to write the invocation on multiple lines */
+        multiline?: boolean;
     }
 }
 
 export class FuncInvocation extends AstNode {
     private func: GoTypeReference;
     private arguments_: AstNode[];
+    private multiline: boolean | undefined;
 
-    constructor({ func, arguments_ }: FuncInvocation.Args) {
+    constructor({ func, arguments_, multiline = true }: FuncInvocation.Args) {
         super();
 
         this.func = func;
         this.arguments_ = arguments_;
+        this.multiline = multiline;
     }
 
     public write(writer: Writer): void {
         writer.writeNode(this.func);
-        writeArguments({ writer, arguments_: this.arguments_ });
+        writeArguments({ writer, arguments_: this.arguments_, multiline: this.multiline });
     }
 }

generators/go-v2/ast/src/ast/GoTypeReference.ts

@@ -1,3 +1,4 @@
+import { Type } from "./Type";
 import { AstNode } from "./core/AstNode";
 import { Writer } from "./core/Writer";
 
@@ -7,17 +8,21 @@ export declare namespace GoTypeReference {
         name: string;
         /* The import path of the Go type */
         importPath: string;
+        /* The generic type parameters, if any */
+        generics?: Type[] | undefined;
     }
 }
 
 export class GoTypeReference extends AstNode {
     public readonly name: string;
     public readonly importPath: string;
+    public readonly generics: Type[] | undefined;
 
-    constructor({ name, importPath }: GoTypeReference.Args) {
+    constructor({ name, importPath, generics }: GoTypeReference.Args) {
         super();
         this.name = name;
         this.importPath = importPath;
+        this.generics = generics;
     }
 
     public write(writer: Writer): void {
@@ -27,5 +32,17 @@ export class GoTypeReference extends AstNode {
         }
         const alias = writer.addImport(this.importPath);
         writer.write(`${alias}.${this.name}`);
+        if (this.generics != null) {
+            writer.write("[");
+            this.generics.forEach((generic, idx) => {
+                if (idx > 0) {
+                    writer.write(", ");
+                }
+                if (generic != null) {
+                    generic.write(writer);
+                }
+            });
+            writer.write("]");
+        }
     }
 }

generators/go-v2/ast/src/ast/Method.ts

@@ -8,12 +8,12 @@ import { Writer } from "./core/Writer";
 
 export declare namespace Method {
     interface Args {
-        /* The name of the method */
-        name: string;
         /* The parameters of the method */
         parameters: Parameter[];
         /* The return type of the method */
         return_: Type[];
+        /* The name of the method */
+        name?: string;
         /* The body of the method */
         body?: CodeBlock;
         /* Documentation for the method */
@@ -24,9 +24,9 @@ export declare namespace Method {
 }
 
 export class Method extends AstNode {
-    public readonly name: string;
     public readonly parameters: Parameter[];
     public readonly return_: Type[];
+    public readonly name: string | undefined;
     public readonly body: CodeBlock | undefined;
     public readonly docs: string | undefined;
     public readonly typeReference: GoTypeReference | undefined;
@@ -43,11 +43,13 @@ export class Method extends AstNode {
 
     public write(writer: Writer): void {
         writer.writeNode(new Comment({ docs: this.docs }));
-        writer.write("func ");
+        writer.write("func");
         if (this.typeReference != null) {
             this.writeReceiver({ writer, typeReference: this.typeReference });
         }
-        writer.write(`${this.name}`);
+        if (this.name != null) {
+            writer.write(` ${this.name}`);
+        }
         if (this.parameters.length === 0) {
             writer.write("() ");
         } else {

generators/go-v2/ast/src/ast/MethodInvocation.ts

@@ -10,26 +10,30 @@ export declare namespace MethodInvocation {
         method: string;
         /* The arguments passed to the method */
         arguments_: AstNode[];
+        /* Whether to write the invocation on multiple lines */
+        multiline?: boolean;
     }
 }
 
 export class MethodInvocation extends AstNode {
     private on: AstNode;
     private method: string;
     private arguments_: AstNode[];
+    private multiline: boolean | undefined;
 
-    constructor({ method, arguments_, on }: MethodInvocation.Args) {
+    constructor({ method, arguments_, on, multiline }: MethodInvocation.Args) {
         super();
 
         this.on = on;
         this.method = method;
         this.arguments_ = arguments_;
+        this.multiline = multiline;
     }
 
     public write(writer: Writer): void {
         this.on.write(writer);
         writer.write(".");
         writer.write(this.method);
-        writeArguments({ writer, arguments_: this.arguments_ });
+        writeArguments({ writer, arguments_: this.arguments_, multiline: this.multiline });
     }
 }

generators/go-v2/ast/src/ast/Pointer.ts

@@ -0,0 +1,23 @@
+import { AstNode } from "./core/AstNode";
+import { Writer } from "./core/Writer";
+
+export declare namespace Pointer {
+    interface Args {
+        /* The value of the pointer */
+        node: AstNode;
+    }
+}
+
+export class Pointer extends AstNode {
+    public readonly node: AstNode;
+
+    constructor({ node }: Pointer.Args) {
+        super();
+        this.node = node;
+    }
+
+    public write(writer: Writer): void {
+        writer.write("*");
+        this.node.write(writer);
+    }
+}

generators/go-v2/ast/src/ast/Selector.ts

@@ -0,0 +1,28 @@
+import { AstNode } from "./core/AstNode";
+import { Writer } from "./core/Writer";
+
+export declare namespace Selector {
+    interface Args {
+        /* The node to select from */
+        on: AstNode;
+        /* The node to select (e.g. a field name) */
+        selector: AstNode;
+    }
+}
+
+export class Selector extends AstNode {
+    public readonly on: AstNode;
+    public readonly selector: AstNode;
+
+    constructor({ on, selector }: Selector.Args) {
+        super();
+        this.on = on;
+        this.selector = selector;
+    }
+
+    public write(writer: Writer): void {
+        writer.writeNode(this.on);
+        writer.write(".");
+        writer.writeNode(this.selector);
+    }
+}

generators/go-v2/ast/src/ast/Struct.ts

@@ -1,6 +1,9 @@
+import { CodeBlock } from "@fern-api/browser-compatible-base-generator";
+
 import { Comment } from "./Comment";
 import { Field } from "./Field";
 import { Method } from "./Method";
+import { Parameter } from "./Parameter";
 import { AstNode } from "./core/AstNode";
 import { Writer } from "./core/Writer";
 
@@ -13,13 +16,19 @@
         /* Docs associated with the class */
         docs?: string;
     }
+
+    interface Constructor {
+        parameters: Parameter[];
+        body: AstNode;
+    }
 }
 
 export class Struct extends AstNode {
     public readonly name: string;
     public readonly importPath: string;
     public readonly docs: string | undefined;
 
+    public constructor_: Struct.Constructor | undefined;
     public readonly fields: Field[] = [];
     public readonly methods: Method[] = [];
 
@@ -30,12 +39,16 @@
         this.docs = docs;
     }
 
-    public addField(field: Field): void {
-        this.fields.push(field);
+    public addConstructor(constructor: Struct.Constructor): void {
+        this.constructor_ = constructor;
     }
 
-    public addMethod(method: Method): void {
-        this.methods.push(method);
+    public addField(...fields: Field[]): void {
+        this.fields.push(...fields);
+    }
+
+    public addMethod(...methods: Method[]): void {
+        this.methods.push(...methods);
     }
 
     public write(writer: Writer): void {
@@ -54,6 +67,11 @@
             writer.writeLine("}");
         }
 
+        if (this.constructor_ != null) {
+            writer.newLine();
+            this.writeConstructor({ writer, constructor: this.constructor_ });
+        }
+
         if (this.methods.length > 0) {
             writer.newLine();
             for (const method of this.methods) {
@@ -62,4 +80,21 @@
             }
         }
     }
+
+    private writeConstructor({ writer, constructor }: { writer: Writer; constructor: Struct.Constructor }): void {
+        writer.write(`func New${this.name}(`);
+        constructor.parameters.forEach((parameter, index) => {
+            if (index > 0) {
+                writer.write(", ");
+            }
+            writer.writeNode(parameter);
+        });
+        writer.write(`) *${this.name} {`);
+        writer.newLine();
+        writer.indent();
+        writer.writeNode(constructor.body);
+        writer.writeNewLineIfLastLineNot();
+        writer.dedent();
+        writer.writeLine(`}`);
+    }
 }