@alloy-js/go 0.0.1

package/src/components/var/declaration.tsx

@@ -0,0 +1,138 @@
+import {
+  Children,
+  ComponentContext,
+  computed,
+  createContext,
+  Declaration,
+  Indent,
+  List,
+  memo,
+  Name,
+  Namekey,
+  Refkey,
+  Show,
+  useContext,
+} from "@alloy-js/core";
+import { useGoScope } from "../../scopes/contexts.js";
+import { GoSourceFileScope } from "../../scopes/source-file.js";
+import { createVariableSymbol } from "../../symbols/factories.js";
+import { LineComment } from "../doc/comment.jsx";
+
+export interface VariableDeclarationProps {
+  /** Variable name */
+  name: string | Namekey;
+  /** Type of the variable declaration */
+  type?: Children;
+  /** Variable refkey */
+  refkey?: Refkey;
+  /** Documentation comment */
+  doc?: Children;
+  /** Whether this is a `const` declaration */
+  const?: boolean;
+  /** Initializer expression */
+  children?: Children;
+}
+
+export interface VariableDeclarationGroupProps {
+  const?: boolean;
+  children: Children;
+}
+
+export interface VariableDeclarationGroupContext {
+  const: boolean;
+  active: boolean;
+}
+
+export const VariableDeclarationGroupContext: ComponentContext<VariableDeclarationGroupContext> =
+  createContext<VariableDeclarationGroupContext>();
+
+export function VariableDeclarationGroup(props: VariableDeclarationGroupProps) {
+  const keyword = computed(() => (props.const ? "const" : "var"));
+
+  return (
+    <VariableDeclarationGroupContext.Provider
+      value={{ active: true, const: !!props.const }}
+    >
+      {keyword} (
+      <Indent trailingBreak>
+        <List hardline>{props.children}</List>
+      </Indent>
+      )
+    </VariableDeclarationGroupContext.Provider>
+  );
+}
+
+export function VariableDeclaration(props: VariableDeclarationProps) {
+  const isFileScope = useGoScope() instanceof GoSourceFileScope;
+  const declarationGroupContext = useContext(VariableDeclarationGroupContext);
+  const inDeclarationGroup = !!declarationGroupContext?.active;
+  const isConst = declarationGroupContext?.const ?? props.const;
+  const symbol = createVariableSymbol(props.name, { refkeys: props.refkey });
+  const content = memo(() => {
+    const keyword = isConst ? "const" : "var";
+
+    if (inDeclarationGroup) {
+      if (!props.type && !props.children) {
+        if (!isConst) {
+          throw new Error(
+            "Variable declaration must have a type or initializer.",
+          );
+        }
+        return <Name />;
+      } else if (props.type && props.children) {
+        return (
+          <>
+            <Name /> {props.type} = {props.children}
+          </>
+        );
+      } else if (props.type) {
+        if (declarationGroupContext?.const) {
+          throw new Error("Const declaration must have an initializer.");
+        }
+        return (
+          <>
+            <Name /> {props.type}
+          </>
+        );
+      } else if (props.children) {
+        return (
+          <>
+            <Name /> = {props.children}
+          </>
+        );
+      }
+    } else {
+      if (!props.type && !props.children) {
+        throw new Error(
+          "Variable declaration must have a type or initializer.",
+        );
+      } else if (!props.children || isConst || props.type || isFileScope) {
+        return (
+          <>
+            {keyword} <Name /> {props.type}
+            {props.type && props.children ? " " : ""}
+            {props.children ? "= " : ""}
+            {props.children}
+          </>
+        );
+      } else {
+        return (
+          <>
+            <Name /> :{props.children ? "= " : ""}
+            {props.children}
+          </>
+        );
+      }
+    }
+  });
+
+  return (
+    <>
+      <Show when={Boolean(props.doc)}>
+        <LineComment children={props.doc} />
+        <hbr />
+      </Show>
+      <Declaration symbol={symbol}>{content}</Declaration>
+    </>
+  );
+}

package/src/components/var/var-declaration.test.tsx

@@ -0,0 +1,236 @@
+import { Output, refkey, render } from "@alloy-js/core";
+import "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { assertFileContents } from "../../../test/utils.js";
+import * as go from "../index.js";
+
+it("works variable", () => {
+  expect(
+    <Output>
+      <go.ModuleDirectory name="github.com/alloy-framework/alloy">
+        <go.SourceDirectory path=".">
+          <go.SourceFile path="test.go">
+            <go.VariableDeclaration name="hi">12</go.VariableDeclaration>
+          </go.SourceFile>
+        </go.SourceDirectory>
+      </go.ModuleDirectory>
+    </Output>,
+  ).toRenderTo(`
+    package alloy
+
+    var hi = 12
+  `);
+});
+
+it("works variable group", () => {
+  expect(
+    <Output>
+      <go.ModuleDirectory name="github.com/alloy-framework/alloy">
+        <go.SourceDirectory path=".">
+          <go.SourceFile path="test.go">
+            <go.VariableDeclarationGroup>
+              <go.VariableDeclaration name="hi1">12</go.VariableDeclaration>
+              <go.VariableDeclaration name="hi2" type="string">
+                12
+              </go.VariableDeclaration>
+              <go.VariableDeclaration
+                name="hi3"
+                type="string"
+              ></go.VariableDeclaration>
+            </go.VariableDeclarationGroup>
+          </go.SourceFile>
+        </go.SourceDirectory>
+      </go.ModuleDirectory>
+    </Output>,
+  ).toRenderTo(`
+    package alloy
+
+    var (
+      hi1 = 12
+      hi2 string = 12
+      hi3 string
+    )
+  `);
+});
+
+it("works const group", () => {
+  expect(
+    <Output>
+      <go.ModuleDirectory name="github.com/alloy-framework/alloy">
+        <go.SourceDirectory path=".">
+          <go.SourceFile path="test.go">
+            <go.VariableDeclarationGroup const>
+              <go.VariableDeclaration name="hi1">12</go.VariableDeclaration>
+              <go.VariableDeclaration name="hi2" type="string">
+                12
+              </go.VariableDeclaration>
+            </go.VariableDeclarationGroup>
+          </go.SourceFile>
+        </go.SourceDirectory>
+      </go.ModuleDirectory>
+    </Output>,
+  ).toRenderTo(`
+    package alloy
+
+    const (
+      hi1 = 12
+      hi2 string = 12
+    )
+  `);
+});
+
+it("works end-to-end", () => {
+  const TestType = refkey("TestType");
+
+  const res = render(
+    <Output>
+      <go.ModuleDirectory name="github.com/alloy-framework/alloy">
+        <go.SourceDirectory path=".">
+          <go.SourceFile path="types.go">
+            <go.TypeDeclaration name="TestType" refkey={TestType}>
+              string
+            </go.TypeDeclaration>
+          </go.SourceFile>
+          <go.SourceFile path="test.go">
+            <go.VariableDeclaration name="hi" type={TestType}>
+              "hello"
+            </go.VariableDeclaration>
+          </go.SourceFile>
+        </go.SourceDirectory>
+      </go.ModuleDirectory>
+    </Output>,
+  );
+
+  assertFileContents(res, {
+    "types.go": `
+      package alloy
+
+      type TestType string
+    `,
+    "test.go": `
+      package alloy
+
+      var hi TestType = "hello"
+    `,
+  });
+});
+
+it("throws end-to-end cross-package with unexported type", () => {
+  const TestType = refkey("TestType");
+
+  expect(() =>
+    render(
+      <Output>
+        <go.ModuleDirectory name="github.com/alloy-framework/alloy">
+          <go.SourceDirectory path="hello">
+            <go.SourceFile path="types.go">
+              <go.TypeDeclaration name="testType" refkey={TestType}>
+                string
+              </go.TypeDeclaration>
+            </go.SourceFile>
+          </go.SourceDirectory>
+          <go.SourceDirectory path="world">
+            <go.SourceFile path="test.go">
+              <go.VariableDeclaration name="hi" type={TestType}>
+                "hello"
+              </go.VariableDeclaration>
+            </go.SourceFile>
+          </go.SourceDirectory>
+        </go.ModuleDirectory>
+      </Output>,
+    ),
+  ).toThrowError(
+    "Can't reference non-exported symbol testType from another package.",
+  );
+});
+
+it("works end-to-end cross-package", () => {
+  const TestType = refkey("TestType");
+
+  const res = render(
+    <Output>
+      <go.ModuleDirectory name="github.com/alloy-framework/alloy">
+        <go.SourceDirectory path="hello">
+          <go.SourceFile path="types.go">
+            <go.TypeDeclaration name="TestType" refkey={TestType}>
+              string
+            </go.TypeDeclaration>
+          </go.SourceFile>
+        </go.SourceDirectory>
+        <go.SourceDirectory path="world">
+          <go.SourceFile path="test.go">
+            <go.VariableDeclaration name="hi" type={TestType}>
+              "hello"
+            </go.VariableDeclaration>
+          </go.SourceFile>
+        </go.SourceDirectory>
+      </go.ModuleDirectory>
+    </Output>,
+  );
+
+  assertFileContents(res, {
+    "hello/types.go": `
+      package hello
+
+      type TestType string
+    `,
+    "world/test.go": `
+      package world
+
+      import "github.com/alloy-framework/alloy/hello"
+
+      var hi hello.TestType = "hello"
+    `,
+  });
+});
+
+it("works with conflict resolution", () => {
+  const TestType1 = refkey("TestType1");
+  const TestType2 = refkey("TestType2");
+
+  const res = render(
+    <Output>
+      <go.ModuleDirectory name="github.com/alloy-framework/alloy">
+        <go.SourceDirectory path="hello" name="hello">
+          <go.SourceFile path="types.go">
+            <go.TypeDeclaration name="TestType" refkey={TestType1}>
+              string
+            </go.TypeDeclaration>
+          </go.SourceFile>
+        </go.SourceDirectory>
+        <go.SourceDirectory path="hello2" name="hello">
+          <go.SourceFile path="types.go">
+            <go.TypeDeclaration name="TestType" refkey={TestType2}>
+              string
+            </go.TypeDeclaration>
+          </go.SourceFile>
+        </go.SourceDirectory>
+        <go.SourceDirectory path="world">
+          <go.SourceFile path="test.go">
+            <go.VariableDeclaration name="hi1" type={TestType1}>
+              "hello"
+            </go.VariableDeclaration>
+            <hbr />
+            <go.VariableDeclaration name="hi2" type={TestType2}>
+              "hello"
+            </go.VariableDeclaration>
+          </go.SourceFile>
+        </go.SourceDirectory>
+      </go.ModuleDirectory>
+    </Output>,
+  );
+
+  assertFileContents(res, {
+    "world/test.go": `
+      package world
+
+      import (
+        "github.com/alloy-framework/alloy/hello"
+        hello_2 "github.com/alloy-framework/alloy/hello2"
+      )
+
+      var hi1 hello.TestType = "hello"
+      var hi2 hello_2.TestType = "hello"
+    `,
+  });
+});

package/src/context/package.ts

@@ -0,0 +1,13 @@
+import { ComponentContext, createContext, useContext } from "@alloy-js/core";
+import { PackageSymbol } from "../symbols/package.js";
+
+interface PackageContext {
+  symbol: PackageSymbol;
+}
+
+export const PackageContext: ComponentContext<PackageContext> =
+  createContext<PackageContext>();
+
+export function usePackageContext() {
+  return useContext(PackageContext);
+}

package/src/create-module.test.tsx

@@ -0,0 +1,128 @@
+import { TestPackage } from "#test/utils.jsx";
+import { namekey, toRefkey } from "@alloy-js/core";
+import { expect, it } from "vitest";
+import { fmt } from "./builtins/fmt/fmt.js";
+import { VariableDeclaration } from "./components/index.js";
+import { createModule, StrictDescriptor } from "./create-module.js";
+
+it("Can reference types which haven't been created yet", () => {
+  const std1 = createModule("std1", {
+    kind: "package",
+    members: {
+      SomeType: {
+        kind: "struct",
+        members: {
+          Special: { kind: "field", type: () => std2.SomeType2 },
+        },
+      },
+    },
+  } satisfies StrictDescriptor);
+
+  const std2 = createModule("std2", {
+    kind: "package",
+    members: {
+      SomeType2: {
+        kind: "struct",
+        members: {
+          Hello: { kind: "field" },
+        },
+      },
+    },
+  } satisfies StrictDescriptor);
+
+  const test = namekey("test");
+
+  expect(
+    <TestPackage>
+      <VariableDeclaration name={test} type={std1.SomeType} />
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    import "std1"
+
+    var test std1.SomeType
+  `);
+});
+
+it("renders as a refkey", () => {
+  const mod = createModule("std", {
+    kind: "package",
+    members: {
+      BinaryReader: {
+        kind: "struct",
+        members: {},
+      },
+    },
+  } satisfies StrictDescriptor);
+
+  expect(
+    <TestPackage>
+      <VariableDeclaration name="test" type={mod.BinaryReader} />
+    </TestPackage>,
+  ).toRenderTo(`
+    package alloy
+
+    import "std"
+
+    var test std.BinaryReader
+  `);
+});
+
+it("has a refkey getter", () => {
+  const std = createModule("std", {
+    kind: "package",
+    members: {
+      SomeType: {
+        kind: "struct",
+        members: {
+          Special: { kind: "field" },
+        },
+      },
+    },
+  } satisfies StrictDescriptor);
+
+  const ioKey = toRefkey(std);
+  expect(ioKey).toBeDefined();
+  const brKey = toRefkey(std.SomeType);
+  expect(brKey).toBeDefined();
+});
+
+it("has built-ins available", () => {
+  const template = <TestPackage>{fmt.Println}("Hello, World!")</TestPackage>;
+
+  expect(template).toRenderTo(`
+    package alloy
+
+    import "fmt"
+
+    fmt.Println("Hello, World!")
+  `);
+});
+
+it("can render multiple times", () => {
+  const mod = createModule("std", {
+    kind: "package",
+    members: {
+      BinaryReader: {
+        kind: "struct",
+        members: {},
+      },
+    },
+  } satisfies StrictDescriptor);
+
+  expect(<TestPackage>{mod.BinaryReader}</TestPackage>).toRenderTo(`
+    package alloy
+
+    import "std"
+
+    std.BinaryReader
+  `);
+  expect(<TestPackage>{mod.BinaryReader}</TestPackage>).toRenderTo(`
+    package alloy
+
+    import "std"
+
+    std.BinaryReader
+  `);
+});