@alloy-js/go 0.0.1

package/src/components/function/function.test.tsx

@@ -0,0 +1,387 @@
+import { Children, code, Output, refkey, Refkey, render } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import { TestPackage } from "../../../test/utils.js";
+import { ModuleDirectory } from "../ModuleDirectory.js";
+import { SourceDirectory } from "../SourceDirectory.js";
+import { SourceFile } from "../SourceFile.js";
+import { StructDeclaration } from "../struct/declaration.js";
+import { TypeDeclaration } from "../type/declaration.js";
+import { FunctionDeclaration, FunctionReceiver } from "./function.js";
+
+const Wrapper = (props: { children: Children; refkey: Refkey }) => (
+  <TestPackage>
+    <TypeDeclaration refkey={props.refkey} name="TestStruct">
+      <StructDeclaration />
+      <hbr />
+    </TypeDeclaration>
+    {props.children}
+  </TestPackage>
+);
+
+it("applies PascalCase naming policy when exported", () => {
+  expect(
+    <TestPackage>
+      <FunctionDeclaration name="MethodOne" />
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    func MethodOne() {}
+  `);
+});
+
+it("applies camelCase naming policy when not exported", () => {
+  expect(
+    <TestPackage>
+      <FunctionDeclaration name="methodOne" />
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    func methodOne() {}
+  `);
+});
+
+it("defines single-line params and return type", () => {
+  const params = [
+    {
+      name: "intParam",
+      type: "int",
+    },
+    {
+      name: "stringParam",
+      type: "string",
+    },
+  ];
+  const res = (
+    <TestPackage>
+      <FunctionDeclaration
+        name="MethodOne"
+        parameters={params}
+        returns="string"
+      />
+    </TestPackage>
+  );
+
+  expect(res).toRenderTo(`
+    package alloy
+
+    func MethodOne(intParam int, stringParam string) string {}
+  `);
+});
+
+it("defines multi-line params and return type", () => {
+  const params = [
+    {
+      name: "intParam",
+      type: "int",
+    },
+    {
+      name: "stringParam",
+      type: "string",
+    },
+    {
+      name: "stringParam2",
+      type: "string",
+    },
+    {
+      name: "stringParam3",
+      type: "string",
+    },
+  ];
+  const res = (
+    <TestPackage>
+      <FunctionDeclaration
+        name="MethodOne"
+        parameters={params}
+        returns="string"
+      />
+    </TestPackage>
+  );
+
+  expect(res).toRenderTo(`
+    package alloy
+
+    func MethodOne(
+      intParam int,
+      stringParam string,
+      stringParam2 string,
+      stringParam3 string,
+    ) string {}
+  `);
+});
+
+it("defines single-line return type", () => {
+  const res = (
+    <TestPackage>
+      <FunctionDeclaration name="MethodOne" returns={["string", "error"]} />
+    </TestPackage>
+  );
+
+  expect(res).toRenderTo(`
+    package alloy
+
+    func MethodOne() (string, error) {}
+  `);
+});
+
+it("defines multi-line return type", () => {
+  const res = (
+    <TestPackage>
+      <FunctionDeclaration
+        name="MethodOne"
+        returns={[
+          "string",
+          "string",
+          "string",
+          "string",
+          "string",
+          "string",
+          "string",
+          "string",
+          "string",
+          "string",
+          "error",
+        ]}
+      />
+    </TestPackage>
+  );
+
+  expect(res).toRenderTo(`
+    package alloy
+
+    func MethodOne() (
+      string,
+      string,
+      string,
+      string,
+      string,
+      string,
+      string,
+      string,
+      string,
+      string,
+      error,
+    ) {}
+  `);
+});
+
+it("specify doc comment", () => {
+  expect(
+    <TestPackage>
+      <FunctionDeclaration
+        name="MethodOne"
+        doc={
+          <>
+            {"This is a test"}
+            <hbr />
+            {"This is another test"}
+          </>
+        }
+      />
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    // This is a test
+    // This is another test
+    func MethodOne() {}
+  `);
+});
+
+it("use single-line form", () => {
+  expect(
+    <TestPackage>
+      <FunctionDeclaration name="MethodOne" singleLine>
+        return nil
+      </FunctionDeclaration>
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    func MethodOne() { return nil }
+  `);
+});
+
+it("use children", () => {
+  expect(
+    <TestPackage>
+      <FunctionDeclaration name="MethodOne">return nil</FunctionDeclaration>
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    func MethodOne() {
+      return nil
+    }
+  `);
+});
+
+it("use multiple children", () => {
+  expect(
+    <TestPackage>
+      <FunctionDeclaration name="MethodOne">
+        {code`
+        lineOne()
+        lineTwo()
+        return nil
+        `}
+      </FunctionDeclaration>
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    func MethodOne() {
+      lineOne()
+      lineTwo()
+      return nil
+    }
+  `);
+});
+
+it("use method", () => {
+  const ReceiverRefkey = refkey("ReceiverRefkey");
+
+  expect(
+    <Wrapper refkey={ReceiverRefkey}>
+      <FunctionDeclaration
+        name="MethodOne"
+        receiver={<FunctionReceiver name="s" type={ReceiverRefkey} />}
+      />
+    </Wrapper>,
+  ).toRenderTo(`
+    package alloy
+
+    type TestStruct struct{}
+    func (s TestStruct) MethodOne() {}
+  `);
+});
+
+it("use method variadic params", () => {
+  const ReceiverRefkey = refkey("ReceiverRefkey");
+
+  expect(
+    <Wrapper refkey={ReceiverRefkey}>
+      <FunctionDeclaration
+        name="MethodOne"
+        receiver={<FunctionReceiver name="s" type={ReceiverRefkey} />}
+        parameters={[
+          { name: "i", type: "int" },
+          { name: "args", type: "string", variadic: true },
+        ]}
+      />
+    </Wrapper>,
+  ).toRenderTo(`
+    package alloy
+
+    type TestStruct struct{}
+    func (s TestStruct) MethodOne(i int, args ...string) {}
+  `);
+});
+
+it("use method cross-package fail", () => {
+  const ReceiverRefkey = refkey("ReceiverRefkey");
+
+  expect(() =>
+    render(
+      <Output>
+        <ModuleDirectory name="github.com/alloy-framework/alloy">
+          <SourceDirectory path="hello">
+            <SourceFile path="types.go">
+              <TypeDeclaration refkey={ReceiverRefkey} name="TestStruct">
+                <StructDeclaration />
+              </TypeDeclaration>
+            </SourceFile>
+          </SourceDirectory>
+          <SourceDirectory path="world">
+            <SourceFile path="test.go">
+              <FunctionDeclaration
+                name="MethodOne"
+                receiver={<FunctionReceiver name="s" type={ReceiverRefkey} />}
+              />
+            </SourceFile>
+          </SourceDirectory>
+        </ModuleDirectory>
+      </Output>,
+    ),
+  ).toThrowError(
+    "Receiver symbol s must be in the same package as the type TestStruct.",
+  );
+});
+
+describe("type parameters", () => {
+  it("function type param", () => {
+    const T = refkey("T");
+    expect(
+      <TestPackage>
+        <FunctionDeclaration
+          name="MethodOne"
+          parameters={[{ name: "arg", type: T }]}
+          typeParameters={[{ name: "T", constraint: "any", refkey: T }]}
+        />
+      </TestPackage>,
+    ).toRenderTo(`
+    package alloy
+
+    func MethodOne[T any](arg T) {}
+  `);
+  });
+
+  it("method auto type param", () => {
+    const ReceiverRefkey = refkey("ReceiverRefkey");
+
+    expect(
+      <TestPackage>
+        <TypeDeclaration
+          refkey={ReceiverRefkey}
+          name="TestStruct"
+          typeParameters={[{ name: "T", constraint: "any" }]}
+        >
+          <StructDeclaration />
+          <hbr />
+        </TypeDeclaration>
+        <FunctionDeclaration
+          name="MethodOne"
+          receiver={<FunctionReceiver name="s" type={ReceiverRefkey} />}
+        />
+      </TestPackage>,
+    ).toRenderTo(`
+    package alloy
+
+    type TestStruct[T any] struct{}
+    func (s TestStruct[T any]) MethodOne() {}
+  `);
+  });
+
+  it("method type param", () => {
+    const ReceiverRefkey = refkey("ReceiverRefkey");
+
+    expect(
+      <TestPackage>
+        <TypeDeclaration
+          refkey={ReceiverRefkey}
+          name="TestStruct"
+          typeParameters={[{ name: "T", constraint: "any" }]}
+        >
+          <StructDeclaration />
+          <hbr />
+        </TypeDeclaration>
+        <FunctionDeclaration
+          name="MethodOne"
+          receiver={
+            <FunctionReceiver
+              name="s"
+              type={ReceiverRefkey}
+              typeParameters={[{ name: "U", constraint: "any" }]}
+            />
+          }
+        />
+      </TestPackage>,
+    ).toRenderTo(`
+    package alloy
+
+    type TestStruct[T any] struct{}
+    func (s TestStruct[U any]) MethodOne() {}
+  `);
+  });
+});

package/src/components/function/function.tsx

@@ -0,0 +1,194 @@
+import {
+  Block,
+  Children,
+  computed,
+  Declaration,
+  DeclarationContext,
+  effect,
+  For,
+  Indent,
+  Name,
+  Namekey,
+  Refkey,
+  Scope,
+  shallowRef,
+  Show,
+  takeSymbols,
+  useContext,
+  watch,
+} from "@alloy-js/core";
+import { useGoScope } from "../../scopes/contexts.js";
+import { createFunctionScope } from "../../scopes/factories.js";
+import { GoSourceFileScope } from "../../scopes/source-file.js";
+import {
+  createFunctionSymbol,
+  createParameterSymbol,
+} from "../../symbols/factories.js";
+import { FunctionSymbol } from "../../symbols/function.js";
+import { GoSymbol } from "../../symbols/go.js";
+import { NamedTypeSymbol } from "../../symbols/named-type.js";
+import { LineComment } from "../doc/comment.jsx";
+import {
+  FunctionParameterProps,
+  FunctionParameters,
+} from "../parameters/parameters.jsx";
+import {
+  TypeParameterProps,
+  TypeParameters,
+} from "../parameters/typeparameters.jsx";
+
+// properties for creating a function
+export interface FunctionProps {
+  name: string | Namekey;
+  parameters?: FunctionParameterProps[];
+  returns?: Children;
+
+  refkey?: Refkey;
+
+  /** Doc comment */
+  doc?: Children;
+
+  /** Go receiver (for methods) */
+  receiver?: Children;
+
+  /** Type parameters for generic functions */
+  typeParameters?: TypeParameterProps[];
+
+  /**
+   * Whether to render the function in a single line.
+   * This will only compile if `children` is a single line as well.
+   * This is not common in Go, so use with caution.
+   */
+  singleLine?: boolean;
+
+  children?: Children;
+}
+
+// a Go function
+export function FunctionDeclaration(props: FunctionProps) {
+  const isFileScope = useGoScope() instanceof GoSourceFileScope;
+
+  if (props.receiver && !isFileScope) {
+    throw new Error("Methods can only be declared in file scope.");
+  }
+
+  const functionSymbol = createFunctionSymbol(props.name, !!props.receiver, {
+    refkeys: props.refkey,
+  });
+
+  // scope for function declaration
+  const functionScope = createFunctionScope();
+
+  // note that scope wraps the function declaration so that the params get the correct scope
+  return (
+    <Declaration symbol={functionSymbol}>
+      <Scope value={functionScope}>
+        <Show when={Boolean(props.doc)}>
+          <LineComment children={props.doc} />
+          <hbr />
+        </Show>
+        func{" "}
+        {props.receiver ?
+          <>({props.receiver}) </>
+        : null}
+        <Name />
+        <TypeParameters parameters={props.typeParameters} />
+        <FunctionParameters parameters={props.parameters} />{" "}
+        {props.returns ?
+          Array.isArray(props.returns) && props.returns.length > 1 ?
+            <>
+              <group>
+                {"("}
+                <Indent softline>
+                  <For
+                    each={props.returns}
+                    joiner={
+                      <>
+                        {","}
+                        <ifBreak flatContents=" ">
+                          <sbr />
+                        </ifBreak>
+                      </>
+                    }
+                    ender={<ifBreak>,</ifBreak>}
+                  >
+                    {(ret) => ret}
+                  </For>
+                </Indent>
+                <sbr />
+                {")"}
+              </group>{" "}
+            </>
+          : <>{props.returns} </>
+        : null}
+        {!props.children ?
+          "{}"
+        : props.singleLine ?
+          <>
+            {"{"} {props.children} {"}"}
+          </>
+        : <Block>{props.children}</Block>}
+      </Scope>
+    </Declaration>
+  );
+}
+
+export interface FuncReceiverProps {
+  name: string | Namekey;
+  type: Children;
+  refkey?: Refkey;
+  typeParameters?: TypeParameterProps[];
+}
+
+export function FunctionReceiver(props: FuncReceiverProps) {
+  const receiverSymbol = createParameterSymbol(props.name, {
+    refkeys: props.refkey,
+  });
+
+  const functionSymbol = useContext(DeclarationContext);
+  if (!(functionSymbol instanceof FunctionSymbol)) {
+    throw new Error("FuncReceiver must be used inside a function.");
+  }
+
+  const typeParams = shallowRef(props.typeParameters ?? []);
+
+  const taken = takeSymbols();
+  effect(() => {
+    if (taken.size !== 1) return;
+    const symbol = Array.from(taken)[0] as GoSymbol;
+    if (symbol.enclosingPackage !== receiverSymbol.enclosingPackage) {
+      throw new Error(
+        `Receiver symbol ${receiverSymbol.name} must be in the same package as the type ${symbol.name}.`,
+      );
+    }
+    if (!(symbol instanceof NamedTypeSymbol)) {
+      throw new Error(
+        `Receiver type must be a named type, got ${symbol.constructor.name}.`,
+      );
+    }
+
+    functionSymbol.spaces = symbol.members;
+    if (!props.typeParameters) {
+      typeParams.value = symbol.typeParameters ?? [];
+    }
+    watch(
+      () => symbol.typeParameters,
+      (newParams) => {
+        if (props.typeParameters) return;
+        typeParams.value = newParams ?? [];
+      },
+    );
+  });
+
+  const typeParamsComponent = computed(() => {
+    if (typeParams.value.length === 0) return null;
+    return <TypeParameters parameters={typeParams.value} />;
+  });
+
+  return (
+    <Declaration symbol={receiverSymbol}>
+      <Name /> {props.type}
+      {typeParamsComponent.value}
+    </Declaration>
+  );
+}

package/src/components/index.ts

@@ -0,0 +1,15 @@
+export * from "./doc/comment.js";
+export * from "./function/function.js";
+export * from "./ImportStatement.js";
+export * from "./interface/declaration.js";
+export * from "./ModuleDirectory.js";
+export * from "./Name.js";
+export * from "./parameters/parameters.js";
+export * from "./parameters/typeparameters.jsx";
+export * from "./pointer/pointer.js";
+export * from "./Reference.js";
+export * from "./SourceDirectory.js";
+export * from "./SourceFile.js";
+export * from "./struct/declaration.js";
+export * from "./type/declaration.js";
+export * from "./var/declaration.js";