@alloy-js/go 0.1.0-dev.2 → 0.1.0-dev.3

package/src/components/function/function.tsx

@@ -1,7 +1,7 @@
 import {
   Block,
   Children,
-  computed,
+  createSymbolSlot,
   Declaration,
   DeclarationContext,
   effect,
@@ -9,13 +9,11 @@ import {
   Indent,
   Name,
   Namekey,
+  onCleanup,
   Refkey,
   Scope,
-  shallowRef,
   Show,
-  takeSymbols,
   useContext,
-  watch,
 } from "@alloy-js/core";
 import { useGoScope } from "../../scopes/contexts.js";
 import { createFunctionScope } from "../../scopes/factories.js";
@@ -27,6 +25,7 @@ import {
 import { FunctionSymbol } from "../../symbols/function.js";
 import { GoSymbol } from "../../symbols/go.js";
 import { NamedTypeSymbol } from "../../symbols/named-type.js";
+import { TypeParameterSymbol } from "../../symbols/type-parameter.js";
 import { LineComment } from "../doc/comment.jsx";
 import {
   FunctionParameterProps,
@@ -150,45 +149,55 @@ export function FunctionReceiver(props: FuncReceiverProps) {
     throw new Error("FuncReceiver must be used inside a function.");
   }
 
-  const typeParams = shallowRef(props.typeParameters ?? []);
+  const FunctionTypeSlot = createSymbolSlot();
 
-  const taken = takeSymbols();
+  // Add the function symbol to the receiver type's members
   effect(() => {
-    if (taken.size !== 1) return;
-    const symbol = Array.from(taken)[0] as GoSymbol;
-    if (symbol.enclosingPackage !== receiverSymbol.enclosingPackage) {
+    const typeSymbol = FunctionTypeSlot.firstSymbol.value as
+      | GoSymbol
+      | undefined;
+    if (!typeSymbol) {
+      return;
+    }
+    if (typeSymbol.enclosingPackage !== receiverSymbol.enclosingPackage) {
       throw new Error(
-        `Receiver symbol ${receiverSymbol.name} must be in the same package as the type ${symbol.name}.`,
+        `Receiver symbol ${receiverSymbol.name} must be in the same package as the type ${typeSymbol.name}.`,
       );
     }
-    if (!(symbol instanceof NamedTypeSymbol)) {
+    if (!(typeSymbol instanceof NamedTypeSymbol)) {
       throw new Error(
-        `Receiver type must be a named type, got ${symbol.constructor.name}.`,
+        `Receiver type must be a named type, got ${typeSymbol.constructor.name}.`,
       );
     }
 
-    functionSymbol.spaces = symbol.members;
-    if (!props.typeParameters) {
-      typeParams.value = symbol.typeParameters ?? [];
-    }
-    watch(
-      () => symbol.typeParameters,
-      (newParams) => {
-        if (props.typeParameters) return;
-        typeParams.value = newParams ?? [];
-      },
-    );
-  });
+    functionSymbol.receiverSymbol = typeSymbol;
 
-  const typeParamsComponent = computed(() => {
-    if (typeParams.value.length === 0) return null;
-    return <TypeParameters parameters={typeParams.value} />;
+    typeSymbol.members.add(functionSymbol);
+
+    onCleanup(() => {
+      functionSymbol.receiverSymbol = undefined;
+      typeSymbol.members.delete(functionSymbol);
+    });
   });
 
   return (
     <Declaration symbol={receiverSymbol}>
-      <Name /> {props.type}
-      {typeParamsComponent.value}
+      <Name /> <FunctionTypeSlot>{props.type}</FunctionTypeSlot>
+      <Show when={!!props.typeParameters}>
+        <TypeParameters parameters={props.typeParameters} />
+      </Show>
+      <Show when={!props.typeParameters && !!functionSymbol.receiverSymbol}>
+        <TypeParameters
+          parameters={[...functionSymbol.receiverSymbol!.typeParameters].map(
+            (s) => {
+              return {
+                name: s.name,
+                constraint: (s as TypeParameterSymbol).constraint,
+              };
+            },
+          )}
+        />
+      </Show>
     </Declaration>
   );
 }

package/src/components/type/declaration.tsx

@@ -15,6 +15,7 @@ import {
 import { createNamedTypeScope } from "../../scopes/factories.js";
 import { createTypeSymbol } from "../../symbols/factories.js";
 import { NamedTypeSymbol } from "../../symbols/named-type.js";
+import { TypeParameterSymbol } from "../../symbols/type-parameter.js";
 import { LineComment } from "../doc/comment.js";
 import {
   TypeParameterProps,
@@ -64,13 +65,21 @@ export interface TypeDeclarationProps {
 export function TypeDeclaration(props: TypeDeclarationProps) {
   const typeGroup = useContext(TypeDeclarationGroupContext);
 
-  const symbol =
-    props.symbol ??
-    createTypeSymbol(props.name, "type", {
+  let symbol = props.symbol;
+  if (!symbol) {
+    symbol = createTypeSymbol(props.name, "type", {
       refkeys: props.refkey,
-      typeParameters: props.typeParameters,
       // TODO: set aliasTarget when alias is true
     });
+
+    for (const typeParameter of props.typeParameters ?? []) {
+      new TypeParameterSymbol(typeParameter.name, symbol.typeParameters, {
+        refkeys: typeParameter.refkey,
+        constraint: typeParameter.constraint,
+      });
+    }
+  }
+
   const typeScope = createNamedTypeScope(symbol);
 
   return (

package/src/symbols/function.ts

@@ -1,5 +1,13 @@
-import { Namekey, OutputSpace } from "@alloy-js/core";
+import {
+  Namekey,
+  OutputSpace,
+  track,
+  TrackOpTypes,
+  trigger,
+  TriggerOpTypes,
+} from "@alloy-js/core";
 import { GoSymbol, GoSymbolOptions } from "./go.js";
+import { NamedTypeSymbol } from "./named-type.js";
 
 /**
  * A symbol for a function in Go, including receivers.
@@ -14,4 +22,25 @@ export class FunctionSymbol extends GoSymbol {
   ) {
     super(name, spaces, options);
   }
+
+  #receiverSymbol?: NamedTypeSymbol = undefined;
+
+  get receiverSymbol(): NamedTypeSymbol | undefined {
+    track(this, TrackOpTypes.GET, "receiverSymbol");
+    return this.#receiverSymbol;
+  }
+
+  set receiverSymbol(value: NamedTypeSymbol | undefined) {
+    if (this.#receiverSymbol === value) {
+      return;
+    }
+    trigger(
+      this,
+      TriggerOpTypes.SET,
+      "receiverSymbol",
+      value,
+      this.#receiverSymbol,
+    );
+    this.#receiverSymbol = value;
+  }
 }

package/src/symbols/named-type.ts

@@ -6,7 +6,6 @@ import {
   trigger,
   TriggerOpTypes,
 } from "@alloy-js/core";
-import { TypeParameterProps } from "../components/parameters/typeparameters.jsx";
 import { GoSymbol, GoSymbolOptions } from "./go.js";
 
 // represents a symbol from a .go file. Struct, interface, etc.
@@ -23,7 +22,7 @@ export type NamedTypeTypeKind =
 export type NamedTypeSymbolKind = "named-type" | "package";
 
 export interface NamedTypeSymbolOptions extends GoSymbolOptions {
-  typeParameters?: TypeParameterProps[];
+  typeParameters?: GoSymbol[];
 }
 
 /**
@@ -31,7 +30,7 @@ export interface NamedTypeSymbolOptions extends GoSymbolOptions {
  */
 export class NamedTypeSymbol extends GoSymbol {
   public readonly symbolKind: NamedTypeSymbolKind = "named-type";
-  public static readonly memberSpaces = ["members"];
+  public static readonly memberSpaces = ["members", "typeParameters"];
 
   constructor(
     name: string | Namekey,
@@ -41,7 +40,6 @@ export class NamedTypeSymbol extends GoSymbol {
   ) {
     super(name, spaces, options);
     this.#typeKind = kind;
-    this.#typeParameters = options?.typeParameters;
   }
 
   #typeKind: NamedTypeTypeKind;
@@ -58,18 +56,8 @@ export class NamedTypeSymbol extends GoSymbol {
     trigger(this, TriggerOpTypes.SET, "typeKind", value, old);
   }
 
-  #typeParameters?: TypeParameterProps[];
   get typeParameters() {
-    track(this, TrackOpTypes.GET, "typeParameters");
-    return this.#typeParameters;
-  }
-  set typeParameters(value: TypeParameterProps[] | undefined) {
-    const old = this.#typeParameters;
-    if (old === value) {
-      return;
-    }
-    this.#typeParameters = value;
-    trigger(this, TriggerOpTypes.SET, "typeParameters", value, old);
+    return this.memberSpaceFor("typeParameters")!;
   }
 
   copy() {

package/src/symbols/type-parameter.ts

@@ -0,0 +1,26 @@
+import { Children, Namekey, OutputSpace } from "@alloy-js/core";
+import { GoSymbol, GoSymbolOptions } from "./go.js";
+
+interface TypeParameterSymbolOptions extends GoSymbolOptions {
+  constraint?: Children;
+}
+/**
+ * A symbol for type parameters in Go.
+ */
+export class TypeParameterSymbol extends GoSymbol {
+  public readonly symbolKind = "type-parameter";
+
+  constructor(
+    name: string | Namekey,
+    spaces: OutputSpace | undefined,
+    options: TypeParameterSymbolOptions = {},
+  ) {
+    super(name, spaces, options);
+    this.#constraint = options.constraint ?? "any";
+  }
+
+  #constraint: Children;
+  get constraint(): Children {
+    return this.#constraint;
+  }
+}

package/temp/api.json

@@ -2258,6 +2258,50 @@
                 }
               ]
             },
+            {
+              "kind": "Property",
+              "canonicalReference": "@alloy-js/go!FunctionSymbol#receiverSymbol:member",
+              "docComment": "",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "get receiverSymbol(): "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "NamedTypeSymbol",
+                  "canonicalReference": "@alloy-js/go!NamedTypeSymbol:class"
+                },
+                {
+                  "kind": "Content",
+                  "text": " | undefined"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";\n\nset receiverSymbol(value: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "NamedTypeSymbol",
+                  "canonicalReference": "@alloy-js/go!NamedTypeSymbol:class"
+                },
+                {
+                  "kind": "Content",
+                  "text": " | undefined);"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": false,
+              "releaseTag": "Public",
+              "name": "receiverSymbol",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 3
+              },
+              "isStatic": false,
+              "isProtected": false,
+              "isAbstract": false
+            },
             {
               "kind": "Property",
               "canonicalReference": "@alloy-js/go!FunctionSymbol#symbolKind:member",
@@ -5324,30 +5368,21 @@
                   "kind": "Content",
                   "text": "get typeParameters(): "
                 },
-                {
-                  "kind": "Reference",
-                  "text": "TypeParameterProps",
-                  "canonicalReference": "@alloy-js/go!TypeParameterProps:interface"
-                },
-                {
-                  "kind": "Content",
-                  "text": "[] | undefined"
-                },
                 {
                   "kind": "Content",
-                  "text": ";\n\nset typeParameters(value: "
+                  "text": "import(\"@alloy-js/core\")."
                 },
                 {
                   "kind": "Reference",
-                  "text": "TypeParameterProps",
-                  "canonicalReference": "@alloy-js/go!TypeParameterProps:interface"
+                  "text": "OutputMemberSpace",
+                  "canonicalReference": "@alloy-js/core!OutputMemberSpace:class"
                 },
                 {
                   "kind": "Content",
-                  "text": "[] | undefined);"
+                  "text": ";"
                 }
               ],
-              "isReadonly": false,
+              "isReadonly": true,
               "isOptional": false,
               "releaseTag": "Public",
               "name": "typeParameters",
@@ -5427,8 +5462,8 @@
                 },
                 {
                   "kind": "Reference",
-                  "text": "TypeParameterProps",
-                  "canonicalReference": "@alloy-js/go!TypeParameterProps:interface"
+                  "text": "GoSymbol",
+                  "canonicalReference": "@alloy-js/go!GoSymbol:class"
                 },
                 {
                   "kind": "Content",