@alloy-js/go 0.0.1

package/src/components/parameters/parameters.tsx

@@ -0,0 +1,74 @@
+import {
+  Children,
+  createSymbolSlot,
+  Declaration,
+  For,
+  Indent,
+  Namekey,
+  Refkey,
+} from "@alloy-js/core";
+import { createParameterSymbol } from "../../symbols/factories.js";
+import { Name } from "../Name.jsx";
+
+export interface FunctionParameterProps {
+  name: string | Namekey;
+  type: Children;
+  variadic?: boolean;
+  refkey?: Refkey;
+}
+
+/** Define a parameter to be used in functions. */
+export function FunctionParameter(props: FunctionParameterProps) {
+  const TypeSlot = createSymbolSlot();
+
+  const memberSymbol = createParameterSymbol(props.name, {
+    refkeys: props.refkey,
+    type: TypeSlot.firstSymbol,
+  });
+
+  return (
+    <Declaration symbol={memberSymbol}>
+      <Name /> {props.variadic ? "..." : null}
+      <TypeSlot>{props.type}</TypeSlot>
+    </Declaration>
+  );
+}
+
+export interface FunctionParametersProps {
+  parameters: FunctionParameterProps[] | undefined;
+}
+
+/** Render a collection of parameters */
+export function FunctionParameters(props: FunctionParametersProps) {
+  const params = props.parameters ?? [];
+  for (let i = 0; i < (params.length ?? 0); i++) {
+    if (i < params.length - 1 && params[i].variadic) {
+      throw new Error("Variadic parameter must be the last parameter.");
+    }
+  }
+  return (
+    <group>
+      {"("}
+      {props.parameters && (
+        <Indent softline>
+          <For
+            each={params}
+            joiner={
+              <>
+                {","}
+                <ifBreak flatContents=" ">
+                  <sbr />
+                </ifBreak>
+              </>
+            }
+            ender={<ifBreak>,</ifBreak>}
+          >
+            {(param) => <FunctionParameter {...param} />}
+          </For>
+        </Indent>
+      )}
+      <sbr />
+      {")"}
+    </group>
+  );
+}

package/src/components/parameters/typeparameters.tsx

@@ -0,0 +1,78 @@
+import {
+  Children,
+  For,
+  Indent,
+  MemberDeclaration,
+  MemberName,
+  Namekey,
+  Refkey,
+} from "@alloy-js/core";
+import { createTypeParameterSymbol } from "../../symbols/factories.js";
+
+/**
+ * Information for a Go generic type parameter.
+ */
+export interface TypeParameterProps {
+  /**
+   * The name of the type parameter.
+   */
+  name: string | Namekey;
+
+  /**
+   * The parameter constraint
+   */
+  constraint: Children;
+
+  /**
+   * A refkey for this type parameter.
+   */
+  refkey?: Refkey;
+}
+
+export function TypeParameter(props: TypeParameterProps) {
+  const symbol = createTypeParameterSymbol(props.name, {
+    refkeys: props.refkey,
+  });
+  return (
+    <MemberDeclaration symbol={symbol}>
+      <MemberName /> {props.constraint}
+    </MemberDeclaration>
+  );
+}
+
+export interface TypeParametersProps {
+  /** Parameters */
+  parameters?: TypeParameterProps[];
+}
+
+export function TypeParameters(props: TypeParametersProps) {
+  if (!props.parameters || props.parameters.length === 0) {
+    return null;
+  }
+
+  return (
+    <group>
+      {"["}
+      {props.parameters && (
+        <Indent softline>
+          <For
+            each={props.parameters}
+            joiner={
+              <>
+                {","}
+                <ifBreak flatContents=" ">
+                  <sbr />
+                </ifBreak>
+              </>
+            }
+            ender={<ifBreak>,</ifBreak>}
+          >
+            {(param) => <TypeParameter {...param} />}
+          </For>
+        </Indent>
+      )}
+      <sbr />
+      {"]"}
+    </group>
+  );
+}

package/src/components/pointer/pointer.tsx

@@ -0,0 +1,12 @@
+import { Children } from "@alloy-js/core";
+
+export interface PointerProps {
+  children: Children;
+}
+
+/**
+ * A Go pointer type that wraps the given type.
+ */
+export function Pointer(props: PointerProps) {
+  return <>*{props.children}</>;
+}

package/src/components/stc/index.ts

@@ -0,0 +1,27 @@
+import * as core from "@alloy-js/core";
+import * as base from "../index.js";
+
+export const LineComment = core.stc(base.LineComment);
+export const BlockComment = core.stc(base.BlockComment);
+export const FunctionDeclaration = core.stc(base.FunctionDeclaration);
+export const FunctionReceiver = core.stc(base.FunctionReceiver);
+export const InterfaceDeclaration = core.stc(base.InterfaceDeclaration);
+export const InterfaceFunction = core.stc(base.InterfaceFunction);
+export const InterfaceEmbed = core.stc(base.InterfaceEmbed);
+export const FunctionParameter = core.stc(base.FunctionParameter);
+export const FunctionParameters = core.stc(base.FunctionParameters);
+export const Pointer = core.stc(base.Pointer);
+export const StructDeclaration = core.stc(base.StructDeclaration);
+export const StructMember = core.stc(base.StructMember);
+export const StructEmbed = core.stc(base.StructEmbed);
+export const TypeDeclarationGroup = core.stc(base.TypeDeclarationGroup);
+export const TypeDeclaration = core.stc(base.TypeDeclaration);
+export const VariableDeclarationGroup = core.stc(base.VariableDeclarationGroup);
+export const VariableDeclaration = core.stc(base.VariableDeclaration);
+export const ImportStatements = core.stc(base.ImportStatements);
+export const SingleImportStatement = core.stc(base.SingleImportStatement);
+export const ModuleDirectory = core.stc(base.ModuleDirectory);
+export const Name = core.stc(base.Name);
+export const Reference = core.stc(base.Reference);
+export const SourceDirectory = core.stc(base.SourceDirectory);
+export const SourceFile = core.stc(base.SourceFile);

package/src/components/struct/declaration.tsx

@@ -0,0 +1,228 @@
+import {
+  Block,
+  Children,
+  computed,
+  Declaration,
+  DeclarationContext,
+  effect,
+  memo,
+  Namekey,
+  Refkey,
+  Scope,
+  Show,
+  takeSymbols,
+  untrack,
+  useContext,
+  watch,
+} from "@alloy-js/core";
+import { useGoScope, useNamedTypeScope } from "../../scopes/contexts.js";
+import { createNamedTypeScope } from "../../scopes/factories.js";
+import { GoNamedTypeScope } from "../../scopes/named-type.js";
+import {
+  createAnonymousTypeSymbol,
+  createStructMemberSymbol,
+} 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 { TypeDeclaration, TypeDeclarationProps } from "../type/declaration.jsx";
+
+/**
+ * Properties for creating a struct declaration.
+ * This can be used for both named and anonymous structs.
+ * For named structs, use `StructTypeDeclarationProps` instead.
+ */
+export interface StructDeclarationProps {
+  refkey?: Refkey;
+  children?: Children;
+
+  /**
+   * Whether to render the struct 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 struct type declaration.
+ * This is a combination of `StructDeclarationProps` and `TypeDeclarationProps`.
+ */
+export interface StructTypeDeclarationProps
+  extends StructDeclarationProps,
+    TypeDeclarationProps {}
+
+/**
+ * Wrapper for creating a named struct type declaration.
+ */
+export function StructTypeDeclaration(props: StructTypeDeclarationProps) {
+  return (
+    <TypeDeclaration {...props}>
+      <StructDeclaration {...props} />
+    </TypeDeclaration>
+  );
+}
+
+/**
+ * Go struct declaration.
+ * @example
+ * ```tsx
+ * <StructDeclaration>
+ *   <StructEmbed pointer>{MyOtherStruct}</StructEmbed>
+ *   <StructMember exported name="MyProperty" type="int" />
+ * </StructDeclaration>
+ * ```
+ * This will produce:
+ * ```go
+ * struct {
+ *   MyOtherStruct
+ *   MyProperty int
+ * }
+ * ```
+ */
+export function StructDeclaration(props: StructDeclarationProps) {
+  const scope = useGoScope();
+  let structScope: GoNamedTypeScope | undefined;
+  if (
+    !(scope instanceof GoNamedTypeScope) ||
+    scope.ownerSymbol.typeKind !== "type"
+  ) {
+    const declSymbol = useContext(DeclarationContext) as
+      | NamedTypeSymbol
+      | undefined;
+    // this is an anonymous struct
+    if (!declSymbol) {
+      // this can only happen when instantiating a struct directly
+      const anonymousSymbol = createAnonymousTypeSymbol("struct");
+      const anonymousScope = createNamedTypeScope(anonymousSymbol);
+      structScope = anonymousScope;
+    } else {
+      // this is most likely a struct field
+      const anonymousScope = createNamedTypeScope(declSymbol);
+      structScope = anonymousScope;
+    }
+  } else {
+    scope.ownerSymbol.typeKind = "struct";
+  }
+
+  const content = memo(() => {
+    if (props.children) {
+      if (props.singleLine) {
+        return (
+          <>
+            {"{"} {props.children} {"}"}
+          </>
+        );
+      } else {
+        return (
+          <>
+            {" "}
+            <Block>{props.children}</Block>
+          </>
+        );
+      }
+    } else {
+      return "{}";
+    }
+  });
+
+  return (
+    <>
+      struct
+      {structScope ?
+        <Scope value={structScope}>{content}</Scope>
+      : content}
+    </>
+  );
+}
+
+export interface StructMemberProps {
+  name: string | Namekey;
+  type: Children;
+  refkey?: Refkey;
+  tag?: string | Record<string, string>;
+  /** Doc comment */
+  doc?: Children;
+}
+
+export function StructMember(props: StructMemberProps) {
+  const symbol = createStructMemberSymbol(props.name, {
+    refkeys: props.refkey,
+  });
+
+  const tagString = computed(() => {
+    if (typeof props.tag === "string") {
+      return props.tag;
+    } else if (typeof props.tag === "object") {
+      return Object.entries(props.tag)
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([key, value]) => `${key}:"${value}"`)
+        .join(" ");
+    }
+    return "";
+  });
+
+  return (
+    <Declaration symbol={symbol}>
+      <Show when={Boolean(props.doc)}>
+        <LineComment children={props.doc} />
+        <hbr />
+      </Show>
+      <Name /> {props.type}
+      {tagString.value === "" ?
+        ""
+      : tagString.value.includes('"') ?
+        ` \`${tagString.value}\``
+      : ` "${tagString.value}"`}
+    </Declaration>
+  );
+}
+
+export interface StructEmbedProps {
+  refkey?: Refkey;
+  children?: Children;
+  /** Doc comment */
+  doc?: Children;
+}
+
+export function StructEmbed(props: StructEmbedProps) {
+  let typeName: string = "<Unresolved symbol>";
+  if (props.children) {
+    if (typeof props.children === "string") {
+      typeName = props.children;
+    }
+  }
+
+  const memberSymbol = createStructMemberSymbol(typeName, {
+    refkeys: props.refkey,
+  });
+
+  const taken = takeSymbols();
+  effect(() => {
+    if (taken.size !== 1) return;
+    untrack(() => {
+      const symbol = Array.from(taken)[0] as GoSymbol;
+      memberSymbol.name = symbol.name;
+      watch(
+        () => symbol.name,
+        () => {
+          memberSymbol.name = symbol.name;
+        },
+      );
+      const namedTypeScope = useNamedTypeScope();
+      // TODO: somehow mark it as "promoted" such that it cannot be constructed directly
+      symbol.copyMembersTo(namedTypeScope.ownerSymbol);
+    });
+  });
+
+  return (
+    <Declaration symbol={memberSymbol}>
+      <Show when={Boolean(props.doc)}>
+        <LineComment children={props.doc} />
+        <hbr />
+      </Show>
+      {props.children}
+    </Declaration>
+  );
+}