@alloy-js/go 0.0.1

package/src/components/interface/declaration.tsx

@@ -0,0 +1,250 @@
+import {
+  Block,
+  Children,
+  Declaration,
+  DeclarationContext,
+  effect,
+  For,
+  memo,
+  Namekey,
+  Refkey,
+  Scope,
+  Show,
+  takeSymbols,
+  useContext,
+  watch,
+} from "@alloy-js/core";
+import { useGoScope, useNamedTypeScope } from "../../scopes/contexts.js";
+import {
+  createFunctionScope,
+  createNamedTypeScope,
+} from "../../scopes/factories.js";
+import { GoNamedTypeScope } from "../../scopes/named-type.js";
+import {
+  createAnonymousTypeSymbol,
+  createInterfaceMemberSymbol,
+} from "../../symbols/factories.js";
+import { GoSymbol } from "../../symbols/go.js";
+import { NamedTypeSymbol } from "../../symbols/named-type.js";
+import { LineComment } from "../doc/comment.js";
+import { Name } from "../Name.js";
+import {
+  FunctionParameterProps,
+  FunctionParameters,
+} from "../parameters/parameters.js";
+import { TypeDeclaration, TypeDeclarationProps } from "../type/declaration.jsx";
+
+/**
+ * Properties for creating an interface declaration.
+ * This can be used for both named and anonymous interfaces.
+ * For named interfaces, use `InterfaceTypeDeclarationProps` instead.
+ */
+export interface InterfaceDeclarationProps {
+  refkey?: Refkey;
+  children?: Children;
+
+  /**
+   * Whether to render the interface 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;
+}
+
+/**
+ * Properties for creating a named interface type declaration.
+ * This is a combination of `InterfaceDeclarationProps` and `TypeDeclarationProps`.
+ */
+export interface InterfaceTypeDeclarationProps
+  extends InterfaceDeclarationProps,
+    TypeDeclarationProps {}
+
+/**
+ * Wrapper for creating a named interface type declaration.
+ */
+export function InterfaceTypeDeclaration(props: InterfaceTypeDeclarationProps) {
+  return (
+    <TypeDeclaration {...props}>
+      <InterfaceDeclaration {...props} />
+    </TypeDeclaration>
+  );
+}
+
+/**
+ * Go interface declaration.
+ * @example
+ * ```tsx
+ * <InterfaceDeclaration>
+ *   <InterfaceEmbed>{MyOtherInterface}</InterfaceEmbed>
+ *   <InterfaceFunction name="MyFunc" parameters={params} returns="int" />
+ * </InterfaceDeclaration>
+ * ```
+ * This will produce:
+ * ```go
+ * interface {
+ *   MyOtherInterface
+ *   func MyFunc(param Param) int
+ * }
+ * ```
+ */
+export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
+  const scope = useGoScope();
+  let interfaceScope: GoNamedTypeScope | undefined;
+  if (
+    !(scope instanceof GoNamedTypeScope) ||
+    scope.ownerSymbol.typeKind !== "type"
+  ) {
+    const declSymbol = useContext(DeclarationContext) as
+      | NamedTypeSymbol
+      | undefined;
+    // this is an anonymous interface
+    if (!declSymbol) {
+      // this can only happen when instantiating an interface directly
+      const anonymousSymbol = createAnonymousTypeSymbol("interface");
+      const anonymousScope = createNamedTypeScope(anonymousSymbol);
+      interfaceScope = anonymousScope;
+    } else {
+      // this is most likely a struct field
+      const anonymousScope = createNamedTypeScope(declSymbol);
+      interfaceScope = anonymousScope;
+    }
+  } else {
+    scope.ownerSymbol.typeKind = "interface";
+  }
+
+  const content = memo(() => {
+    if (props.children) {
+      if (props.singleLine) {
+        return (
+          <>
+            {"{"} {props.children} {"}"}
+          </>
+        );
+      } else {
+        return (
+          <>
+            {" "}
+            <Block>{props.children}</Block>
+          </>
+        );
+      }
+    } else {
+      return "{}";
+    }
+  });
+
+  return (
+    <>
+      interface
+      {interfaceScope ?
+        <Scope value={interfaceScope}>{content}</Scope>
+      : content}
+    </>
+  );
+}
+
+export interface InterfaceFunctionProps {
+  name: string | Namekey;
+  parameters?: FunctionParameterProps[];
+  returns?: Children;
+  refkey?: Refkey;
+  /** Doc comment */
+  doc?: Children;
+}
+
+export function InterfaceFunction(props: InterfaceFunctionProps) {
+  const symbol = createInterfaceMemberSymbol(props.name, {
+    refkeys: props.refkey,
+  });
+  const functionScope = createFunctionScope();
+
+  return (
+    <Declaration symbol={symbol}>
+      <Scope value={functionScope}>
+        <Show when={Boolean(props.doc)}>
+          <LineComment children={props.doc} />
+          <hbr />
+        </Show>
+        func <Name />
+        <FunctionParameters parameters={props.parameters} />
+        {props.returns ?
+          <> {props.returns}</>
+        : null}
+      </Scope>
+    </Declaration>
+  );
+}
+
+export interface InterfaceEmbedProps {
+  refkey?: Refkey;
+  children?: Children;
+  /** Doc comment */
+  doc?: Children;
+}
+
+export function InterfaceEmbed(props: InterfaceEmbedProps) {
+  let typeName: string = "<Unresolved symbol>";
+  if (props.children) {
+    if (typeof props.children === "string") {
+      typeName = props.children;
+    }
+  }
+
+  const memberSymbol = createInterfaceMemberSymbol(typeName, {
+    refkeys: props.refkey,
+  });
+
+  const taken = takeSymbols();
+  effect(() => {
+    if (taken.size !== 1) return;
+    const symbol = Array.from(taken)[0] as GoSymbol;
+    memberSymbol.name = symbol.name;
+    watch(
+      () => symbol.name,
+      () => {
+        memberSymbol.name = symbol.name;
+      },
+    );
+    const namedTypeScope = useNamedTypeScope();
+    symbol.copyMembersTo(namedTypeScope.ownerSymbol);
+  });
+
+  return (
+    <Declaration symbol={memberSymbol}>
+      <Show when={Boolean(props.doc)}>
+        <LineComment children={props.doc} />
+        <hbr />
+      </Show>
+      {props.children}
+    </Declaration>
+  );
+}
+
+export interface TypeConstraintProps {
+  constraints?: Children[];
+  children?: Children;
+}
+
+export function TypeConstraint(props: TypeConstraintProps) {
+  const constraints: Children[] = [];
+  if (!props.constraints || props.constraints.length === 0) {
+    if (props.children) {
+      constraints.push(props.children);
+    } else {
+      throw new Error("TypeConstraint requires constraints or children.");
+    }
+  } else {
+    if (props.children) {
+      throw new Error(
+        "TypeConstraint cannot have both constraints and children.",
+      );
+    }
+    constraints.push(...props.constraints);
+  }
+
+  return (
+    <For each={constraints} joiner=" | ">
+      {(constraint) => <>{constraint}</>}
+    </For>
+  );
+}

package/src/components/interface/interface.test.tsx

@@ -0,0 +1,390 @@
+import { List, Output, refkey, render } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import { assertFileContents, TestPackage } from "../../../test/utils.js";
+import { ModuleDirectory } from "../ModuleDirectory.jsx";
+import { SourceDirectory } from "../SourceDirectory.jsx";
+import { SourceFile } from "../SourceFile.jsx";
+import { TypeDeclaration } from "../type/declaration.js";
+import {
+  InterfaceDeclaration,
+  InterfaceEmbed,
+  InterfaceFunction,
+  TypeConstraint,
+} from "./declaration.jsx";
+
+function Wrapper(props: { children: any }) {
+  return (
+    <TestPackage>
+      <TypeDeclaration name="TestInterface">
+        <InterfaceDeclaration>{props.children}</InterfaceDeclaration>
+      </TypeDeclaration>
+    </TestPackage>
+  );
+}
+
+it("declares interface with no members", () => {
+  expect(
+    <TestPackage>
+      <TypeDeclaration name="test">
+        <InterfaceDeclaration />
+      </TypeDeclaration>
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    type test interface{}
+  `);
+});
+
+it("specify doc comment", () => {
+  expect(
+    <TestPackage>
+      <TypeDeclaration name="test" doc="This is a test">
+        <InterfaceDeclaration />
+      </TypeDeclaration>
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    // This is a test
+    type test interface{}
+  `);
+});
+
+// describe("with type parameters", () => {
+//   it("reference parameters", () => {
+//     const typeParameters: TypeParameterProps[] = [
+//       {
+//         name: "T",
+//         refkey: refkey(),
+//       },
+//       {
+//         name: "U",
+//         refkey: refkey(),
+//       },
+//     ];
+//
+//     expect(
+//       <TestPackage>
+//         <TypeDeclaration name="Test">
+//           <InterfaceDeclaration public name="Test" typeParameters={typeParameters}>
+//             <List>
+//               <Property name="PropA" type={typeParameters[0].refkey} get set />
+//               <Property name="PropB" type={typeParameters[1].refkey} get set />
+//             </List>
+//           </InterfaceDeclaration>
+//         </TypeDeclaration>
+//       </TestPackage>,
+//     ).toRenderTo(`
+//       public struct Test<T, U>
+//       {
+//           T PropA { get; set; }
+//           U PropB { get; set; }
+//       }
+//     `);
+//   });
+//
+//   it("defines with constraints", () => {
+//     const typeParameters: TypeParameterProps[] = [
+//       {
+//         name: "T",
+//         constraints: "IFoo",
+//       },
+//       {
+//         name: "U",
+//         constraints: "IBar",
+//       },
+//     ];
+//
+//     expect(
+//       <TestPackage>
+//         <TypeDeclaration name="Test">
+//           <InterfaceDeclaration public name="Test" typeParameters={typeParameters}>
+//             // Body
+//           </InterfaceDeclaration>
+//         </TypeDeclaration>
+//       </TestPackage>,
+//     ).toRenderTo(`
+//       public struct Test<T, U>
+//           where T : IFoo
+//           where U : IBar
+//       {
+//           // Body
+//       }
+//     `);
+//   });
+// });
+
+it("defines fields", () => {
+  expect(
+    <TestPackage>
+      <TypeDeclaration name="TestInterface">
+        <InterfaceDeclaration>
+          <List>
+            <InterfaceFunction
+              name="FunctionOne"
+              parameters={[{ name: "hi", type: "string" }]}
+              returns={"string"}
+            />
+            <InterfaceFunction name="functionTwo" returns="int" />
+          </List>
+        </InterfaceDeclaration>
+      </TypeDeclaration>
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    type TestInterface interface {
+      func FunctionOne(hi string) string
+      func functionTwo() int
+    }
+  `);
+});
+
+describe("naming", () => {
+  it("public field is PascalCase", () => {
+    expect(
+      <Wrapper>
+        <List>
+          <InterfaceFunction name="MemberOne" returns="string" />
+        </List>
+      </Wrapper>,
+    ).toRenderTo(`
+      package alloy
+
+      type TestInterface interface {
+        func MemberOne() string
+      }
+    `);
+  });
+
+  it("private field are camelCase", () => {
+    expect(
+      <Wrapper>
+        <List>
+          <InterfaceFunction name="memberOne" returns="string" />
+        </List>
+      </Wrapper>,
+    ).toRenderTo(`
+    package alloy
+
+    type TestInterface interface {
+      func memberOne() string
+    }
+  `);
+  });
+});
+
+describe("embedded", () => {
+  it("embed using children", () => {
+    const TestInterfaceEmbed = refkey("TestInterfaceEmbed");
+    expect(
+      <TestPackage>
+        <TypeDeclaration name="TestInterface">
+          <InterfaceDeclaration>
+            <List>
+              <InterfaceFunction name="MemberOne" returns="string" />
+            </List>
+          </InterfaceDeclaration>
+        </TypeDeclaration>
+        <hbr />
+        <TypeDeclaration name="TestInterface2">
+          <InterfaceDeclaration>
+            <List>
+              <InterfaceEmbed refkey={TestInterfaceEmbed}>
+                TestInterface
+              </InterfaceEmbed>
+              <InterfaceFunction name="MemberOne" returns="string" />
+            </List>
+          </InterfaceDeclaration>
+        </TypeDeclaration>
+        <hbr />
+        {TestInterfaceEmbed}
+      </TestPackage>,
+    ).toRenderTo(`
+      package alloy
+
+      type TestInterface interface {
+        func MemberOne() string
+      }
+      type TestInterface2 interface {
+        TestInterface
+        func MemberOne() string
+      }
+      TestInterface2.TestInterface
+    `);
+  });
+
+  it("embed using refkey", () => {
+    const TestInterface = refkey("TestInterface");
+    const TestInterfaceEmbed = refkey("TestInterfaceEmbed");
+
+    expect(
+      <TestPackage>
+        <TypeDeclaration name="TestInterface" refkey={TestInterface}>
+          <InterfaceDeclaration>
+            <List>
+              <InterfaceFunction name="MemberOne" returns="string" />
+            </List>
+          </InterfaceDeclaration>
+        </TypeDeclaration>
+        <hbr />
+        <TypeDeclaration name="TestInterface2">
+          <InterfaceDeclaration>
+            <List>
+              <InterfaceEmbed refkey={TestInterfaceEmbed}>
+                {TestInterface}
+              </InterfaceEmbed>
+              <InterfaceFunction name="MemberOne" returns="string" />
+            </List>
+          </InterfaceDeclaration>
+        </TypeDeclaration>
+        <hbr />
+        {TestInterfaceEmbed}
+      </TestPackage>,
+    ).toRenderTo(`
+      package alloy
+
+      type TestInterface interface {
+        func MemberOne() string
+      }
+      type TestInterface2 interface {
+        TestInterface
+        func MemberOne() string
+      }
+      TestInterface2.TestInterface
+    `);
+  });
+
+  it("embed using cross-package refkey", () => {
+    const TestInterface = refkey("TestInterface");
+    const TestInterfaceEmbed = refkey("TestInterfaceEmbed");
+
+    const res = render(
+      <Output>
+        <ModuleDirectory name="github.com/alloy-framework/alloy">
+          <SourceDirectory path=".">
+            <SourceDirectory path="hello">
+              <SourceFile path="types.go">
+                <TypeDeclaration name="TestInterface" refkey={TestInterface}>
+                  <InterfaceDeclaration>
+                    <List>
+                      <InterfaceFunction name="MemberOne" returns="string" />
+                    </List>
+                  </InterfaceDeclaration>
+                </TypeDeclaration>
+              </SourceFile>
+            </SourceDirectory>
+            <SourceFile path="Test.go">
+              <TypeDeclaration name="TestInterface2">
+                <InterfaceDeclaration>
+                  <List>
+                    <InterfaceEmbed refkey={TestInterfaceEmbed}>
+                      {TestInterface}
+                    </InterfaceEmbed>
+                    <InterfaceFunction name="MemberOne" returns="string" />
+                  </List>
+                </InterfaceDeclaration>
+              </TypeDeclaration>
+              <hbr />
+              {TestInterfaceEmbed}
+            </SourceFile>
+          </SourceDirectory>
+        </ModuleDirectory>
+      </Output>,
+    );
+
+    assertFileContents(res, {
+      "hello/types.go": `
+        package hello
+
+        type TestInterface interface {
+          func MemberOne() string
+        }
+      `,
+      "Test.go": `
+        package alloy
+
+        import "github.com/alloy-framework/alloy/hello"
+
+        type TestInterface2 interface {
+          hello.TestInterface
+          func MemberOne() string
+        }
+        TestInterface2.TestInterface
+      `,
+    });
+  });
+});
+
+describe("constraints", () => {
+  it("test single constraint", () => {
+    const TestInterface = refkey("TestInterface");
+    expect(
+      <TestPackage>
+        <TypeDeclaration name="TestInterface" refkey={TestInterface}>
+          <InterfaceDeclaration>
+            <List>
+              <InterfaceFunction name="MemberOne" returns="string" />
+            </List>
+          </InterfaceDeclaration>
+        </TypeDeclaration>
+        <hbr />
+        <TypeDeclaration name="TestInterface2">
+          <InterfaceDeclaration>
+            <List>
+              <TypeConstraint>{TestInterface}</TypeConstraint>
+              <InterfaceFunction name="MemberOne" returns="string" />
+            </List>
+          </InterfaceDeclaration>
+        </TypeDeclaration>
+      </TestPackage>,
+    ).toRenderTo(`
+      package alloy
+
+      type TestInterface interface {
+        func MemberOne() string
+      }
+      type TestInterface2 interface {
+        TestInterface
+        func MemberOne() string
+      }
+    `);
+  });
+
+  it("test multiple constraint", () => {
+    const TestInterface = refkey("TestInterface");
+    expect(
+      <TestPackage>
+        <TypeDeclaration name="TestInterface" refkey={TestInterface}>
+          <InterfaceDeclaration>
+            <List>
+              <InterfaceFunction name="MemberOne" returns="string" />
+            </List>
+          </InterfaceDeclaration>
+        </TypeDeclaration>
+        <hbr />
+        <TypeDeclaration name="TestInterface2">
+          <InterfaceDeclaration>
+            <List>
+              <TypeConstraint>{TestInterface}</TypeConstraint>
+              <TypeConstraint constraints={[TestInterface, "string", "~int"]} />
+              <InterfaceFunction name="MemberOne" returns="string" />
+            </List>
+          </InterfaceDeclaration>
+        </TypeDeclaration>
+      </TestPackage>,
+    ).toRenderTo(`
+      package alloy
+
+      type TestInterface interface {
+        func MemberOne() string
+      }
+      type TestInterface2 interface {
+        TestInterface
+        TestInterface | string | ~int
+        func MemberOne() string
+      }
+    `);
+  });
+});

package/src/components/package.test.tsx

@@ -0,0 +1,63 @@
+import { Output } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { ModuleDirectory } from "./ModuleDirectory.jsx";
+import { SourceDirectory } from "./SourceDirectory.jsx";
+import { SourceFile } from "./SourceFile.jsx";
+import { VariableDeclaration } from "./var/declaration.jsx";
+
+it("defines multiple packages and source files with unique content", () => {
+  const tree = (
+    <Output>
+      <ModuleDirectory name="github.com/alloy-framework/alloy">
+        <SourceDirectory path="package1">
+          <SourceFile path="Model1.go">
+            <VariableDeclaration name="Model1" type="string">
+              "This is Model1"
+            </VariableDeclaration>
+          </SourceFile>
+          <SourceFile path="Model2.go">
+            <VariableDeclaration name="Model2" type="string">
+              "This is Model2"
+            </VariableDeclaration>
+          </SourceFile>
+        </SourceDirectory>
+        <SourceDirectory path="package2">
+          <SourceFile path="Model3.go">
+            <VariableDeclaration name="Model3" type="string">
+              "This is Model3"
+            </VariableDeclaration>
+          </SourceFile>
+          <SourceFile path="Model4.go">
+            <VariableDeclaration name="Model4" type="string">
+              "This is Model4"
+            </VariableDeclaration>
+          </SourceFile>
+        </SourceDirectory>
+      </ModuleDirectory>
+    </Output>
+  );
+
+  expect(tree).toRenderTo({
+    "package1/Model1.go": d`
+      package package1
+
+      var Model1 string = "This is Model1"
+    `,
+    "package1/Model2.go": d`
+      package package1
+
+      var Model2 string = "This is Model2"
+    `,
+    "package2/Model3.go": d`
+      package package2
+      
+      var Model3 string = "This is Model3"
+    `,
+    "package2/Model4.go": d`
+      package package2
+      
+      var Model4 string = "This is Model4"
+    `,
+  });
+});