@alloy-js/go 0.0.1

package/src/builtins/net/net.ts

@@ -0,0 +1,502 @@
+import { createModule, StrictDescriptor } from "../../create-module.js";
+import { ioRef } from "../io/io.js";
+
+export const net = createModule(
+  "net",
+  {
+    kind: "package",
+    members: {
+      http: {
+        kind: "package",
+        members: {
+          MethodGet: { kind: "var" },
+          MethodHead: { kind: "var" },
+          MethodPost: { kind: "var" },
+          MethodPut: { kind: "var" },
+          MethodPatch: { kind: "var" },
+          MethodDelete: { kind: "var" },
+          MethodConnect: { kind: "var" },
+          MethodOptions: { kind: "var" },
+          MethodTrace: { kind: "var" },
+          StatusContinue: { kind: "var" },
+          StatusSwitchingProtocols: { kind: "var" },
+          StatusProcessing: { kind: "var" },
+          StatusEarlyHints: { kind: "var" },
+          StatusOK: { kind: "var" },
+          StatusCreated: { kind: "var" },
+          StatusAccepted: { kind: "var" },
+          StatusNonAuthoritativeInfo: { kind: "var" },
+          StatusNoContent: { kind: "var" },
+          StatusResetContent: { kind: "var" },
+          StatusPartialContent: { kind: "var" },
+          StatusMultiStatus: { kind: "var" },
+          StatusAlreadyReported: { kind: "var" },
+          StatusIMUsed: { kind: "var" },
+          StatusMultipleChoices: { kind: "var" },
+          StatusMovedPermanently: { kind: "var" },
+          StatusFound: { kind: "var" },
+          StatusSeeOther: { kind: "var" },
+          StatusNotModified: { kind: "var" },
+          StatusUseProxy: { kind: "var" },
+          StatusTemporaryRedirect: { kind: "var" },
+          StatusPermanentRedirect: { kind: "var" },
+          StatusBadRequest: { kind: "var" },
+          StatusUnauthorized: { kind: "var" },
+          StatusPaymentRequired: { kind: "var" },
+          StatusForbidden: { kind: "var" },
+          StatusNotFound: { kind: "var" },
+          StatusMethodNotAllowed: { kind: "var" },
+          StatusNotAcceptable: { kind: "var" },
+          StatusProxyAuthRequired: { kind: "var" },
+          StatusRequestTimeout: { kind: "var" },
+          StatusConflict: { kind: "var" },
+          StatusGone: { kind: "var" },
+          StatusLengthRequired: { kind: "var" },
+          StatusPreconditionFailed: { kind: "var" },
+          StatusRequestEntityTooLarge: { kind: "var" },
+          StatusRequestURITooLong: { kind: "var" },
+          StatusUnsupportedMediaType: { kind: "var" },
+          StatusRequestedRangeNotSatisfiable: { kind: "var" },
+          StatusExpectationFailed: { kind: "var" },
+          StatusTeapot: { kind: "var" },
+          StatusMisdirectedRequest: { kind: "var" },
+          StatusUnprocessableEntity: { kind: "var" },
+          StatusLocked: { kind: "var" },
+          StatusFailedDependency: { kind: "var" },
+          StatusTooEarly: { kind: "var" },
+          StatusUpgradeRequired: { kind: "var" },
+          StatusPreconditionRequired: { kind: "var" },
+          StatusTooManyRequests: { kind: "var" },
+          StatusRequestHeaderFieldsTooLarge: { kind: "var" },
+          StatusUnavailableForLegalReasons: { kind: "var" },
+          StatusInternalServerError: { kind: "var" },
+          StatusNotImplemented: { kind: "var" },
+          StatusBadGateway: { kind: "var" },
+          StatusServiceUnavailable: { kind: "var" },
+          StatusGatewayTimeout: { kind: "var" },
+          StatusHTTPVersionNotSupported: { kind: "var" },
+          StatusVariantAlsoNegotiates: { kind: "var" },
+          StatusInsufficientStorage: { kind: "var" },
+          StatusLoopDetected: { kind: "var" },
+          StatusNotExtended: { kind: "var" },
+          StatusNetworkAuthenticationRequired: { kind: "var" },
+          DefaultMaxHeaderBytes: { kind: "var" },
+          DefaultMaxIdleConnsPerHost: { kind: "var" },
+          TimeFormat: { kind: "var" },
+          TrailerPrefix: { kind: "var" },
+          ErrNotSupported: { kind: "var" },
+          ErrMissingBoundary: { kind: "var" },
+          ErrNotMultipart: { kind: "var" },
+          ErrBodyNotAllowed: { kind: "var" },
+          ErrHijacked: { kind: "var" },
+          ErrContentLength: { kind: "var" },
+          ServerContextKey: { kind: "var" },
+          LocalAddrContextKey: { kind: "var" },
+          DefaultClient: { kind: "var" },
+          DefaultServeMux: { kind: "var" },
+          ErrAbortHandler: { kind: "var" },
+          ErrBodyReadAfterClose: { kind: "var" },
+          ErrHandlerTimeout: { kind: "var" },
+          ErrLineTooLong: { kind: "var" },
+          ErrMissingFile: { kind: "var" },
+          ErrNoCookie: { kind: "var" },
+          ErrNoLocation: { kind: "var" },
+          ErrSchemeMismatch: { kind: "var" },
+          ErrServerClosed: { kind: "var" },
+          ErrSkipAltProtocol: { kind: "var" },
+          ErrUseLastResponse: { kind: "var" },
+          NoBody: { kind: "var" },
+          CanonicalHeaderKey: { kind: "function" },
+          DetectContentType: { kind: "function" },
+          Error: { kind: "function" },
+          Handle: { kind: "function" },
+          HandleFunc: { kind: "function" },
+          ListenAndServe: { kind: "function" },
+          ListenAndServeTLS: { kind: "function" },
+          MaxBytesReader: { kind: "function" },
+          NotFound: { kind: "function" },
+          ParseHTTPVersion: { kind: "function" },
+          ParseTime: { kind: "function" },
+          ProxyFromEnvironment: { kind: "function" },
+          ProxyURL: { kind: "function" },
+          Redirect: { kind: "function" },
+          Serve: { kind: "function" },
+          ServeContent: { kind: "function" },
+          ServeFile: { kind: "function" },
+          ServeFileFS: { kind: "function" },
+          ServeTLS: { kind: "function" },
+          SetCookie: { kind: "function" },
+          StatusText: { kind: "function" },
+          Client: {
+            kind: "struct",
+            members: {
+              Transport: { kind: "field" },
+              CheckRedirect: { kind: "field" },
+              Jar: { kind: "field" },
+              Timeout: { kind: "field" },
+              CloseIdleConnections: { kind: "method" },
+              Do: { kind: "method" },
+              Get: { kind: "method" },
+              Head: { kind: "method" },
+              Post: { kind: "method" },
+              PostForm: { kind: "method" },
+            },
+          },
+          ConnState: {
+            kind: "type",
+            members: {
+              String: { kind: "method" },
+            },
+          },
+          StateNew: { kind: "var" },
+          StateActive: { kind: "var" },
+          StateIdle: { kind: "var" },
+          StateHijacked: { kind: "var" },
+          StateClosed: { kind: "var" },
+          Cookie: {
+            kind: "struct",
+            members: {
+              Name: { kind: "field" },
+              Value: { kind: "field" },
+              Quoted: { kind: "field" },
+              Path: { kind: "field" },
+              Domain: { kind: "field" },
+              Expires: { kind: "field" },
+              RawExpires: { kind: "field" },
+              MaxAge: { kind: "field" },
+              Secure: { kind: "field" },
+              HttpOnly: { kind: "field" },
+              SameSite: { kind: "field" },
+              Partitioned: { kind: "field" },
+              Raw: { kind: "field" },
+              Unparsed: { kind: "field" },
+              String: { kind: "method" },
+              Valid: { kind: "method" },
+            },
+          },
+          ParseCookie: { kind: "function" },
+          ParseSetCookie: { kind: "function" },
+          CookieJar: {
+            kind: "interface",
+            members: {
+              SetCookies: { kind: "field" },
+              Cookies: { kind: "field" },
+            },
+          },
+          CrossOriginProtection: {
+            kind: "struct",
+            members: {
+              AddInsecureBypassPattern: { kind: "method" },
+              AddTrustedOrigin: { kind: "method" },
+              Check: { kind: "method" },
+              Handler: { kind: "method" },
+              SetDenyHandler: { kind: "method" },
+            },
+          },
+          NewCrossOriginProtection: { kind: "function" },
+          Dir: {
+            kind: "type",
+            members: {
+              Open: { kind: "method" },
+            },
+          },
+          File: {
+            kind: "interface",
+            members: {
+              Closer: { kind: "embed", type: () => ioRef.Closer },
+              Reader: { kind: "embed", type: () => ioRef.Reader },
+              Seeker: { kind: "embed", type: () => ioRef.Seeker },
+              Readdir: { kind: "field" },
+              Stat: { kind: "field" },
+            },
+          },
+          FileSystem: {
+            kind: "interface",
+            members: {
+              Open: { kind: "field" },
+            },
+          },
+          FS: { kind: "function" },
+          Flusher: {
+            kind: "interface",
+            members: {
+              Flush: { kind: "field" },
+            },
+          },
+          HTTP2Config: {
+            kind: "struct",
+            members: {
+              MaxConcurrentStreams: { kind: "field" },
+              MaxDecoderHeaderTableSize: { kind: "field" },
+              MaxEncoderHeaderTableSize: { kind: "field" },
+              MaxReadFrameSize: { kind: "field" },
+              MaxReceiveBufferPerConnection: { kind: "field" },
+              MaxReceiveBufferPerStream: { kind: "field" },
+              SendPingTimeout: { kind: "field" },
+              PingTimeout: { kind: "field" },
+              WriteByteTimeout: { kind: "field" },
+              CountError: { kind: "field" },
+            },
+          },
+          Handler: {
+            kind: "interface",
+            members: {
+              ServeHTTP: { kind: "field" },
+            },
+          },
+          AllowQuerySemicolons: { kind: "function" },
+          FileServer: { kind: "function" },
+          FileServerFS: { kind: "function" },
+          MaxBytesHandler: { kind: "function" },
+          NotFoundHandler: { kind: "function" },
+          RedirectHandler: { kind: "function" },
+          StripPrefix: { kind: "function" },
+          TimeoutHandler: { kind: "function" },
+          HandlerFunc: {
+            kind: "type",
+            members: {
+              ServeHTTP: { kind: "method" },
+            },
+          },
+          Header: {
+            kind: "type",
+            members: {
+              Add: { kind: "method" },
+              Clone: { kind: "method" },
+              Del: { kind: "method" },
+              Get: { kind: "method" },
+              Set: { kind: "method" },
+              Values: { kind: "method" },
+              Write: { kind: "method" },
+              WriteSubset: { kind: "method" },
+            },
+          },
+          Hijacker: {
+            kind: "interface",
+            members: {
+              Hijack: { kind: "field" },
+            },
+          },
+          MaxBytesError: {
+            kind: "struct",
+            members: {
+              Error: { kind: "method" },
+            },
+          },
+          Protocols: {
+            kind: "struct",
+            members: {
+              HTTP1: { kind: "method" },
+              HTTP2: { kind: "method" },
+              SetHTTP1: { kind: "method" },
+              SetHTTP2: { kind: "method" },
+              SetUnencryptedHTTP2: { kind: "method" },
+              String: { kind: "method" },
+              UnencryptedHTTP2: { kind: "method" },
+            },
+          },
+          PushOptions: {
+            kind: "struct",
+            members: {
+              Method: { kind: "field" },
+              Header: { kind: "field" },
+            },
+          },
+          Pusher: {
+            kind: "interface",
+            members: {
+              Push: { kind: "field" },
+            },
+          },
+          Request: {
+            kind: "struct",
+            members: {
+              Method: { kind: "field" },
+              URL: { kind: "field" },
+              Proto: { kind: "field" },
+              ProtoMajor: { kind: "field" },
+              ProtoMinor: { kind: "field" },
+              Header: { kind: "field" },
+              Body: { kind: "field" },
+              GetBody: { kind: "field" },
+              ContentLength: { kind: "field" },
+              TransferEncoding: { kind: "field" },
+              Close: { kind: "field" },
+              Host: { kind: "field" },
+              Form: { kind: "field" },
+              PostForm: { kind: "field" },
+              MultipartForm: { kind: "field" },
+              Trailer: { kind: "field" },
+              RemoteAddr: { kind: "field" },
+              RequestURI: { kind: "field" },
+              TLS: { kind: "field" },
+              Cancel: { kind: "field" },
+              Response: { kind: "field" },
+              Pattern: { kind: "field" },
+              AddCookie: { kind: "method" },
+              BasicAuth: { kind: "method" },
+              Clone: { kind: "method" },
+              Context: { kind: "method" },
+              Cookie: { kind: "method" },
+              Cookies: { kind: "method" },
+              CookiesNamed: { kind: "method" },
+              FormFile: { kind: "method" },
+              FormValue: { kind: "method" },
+              MultipartReader: { kind: "method" },
+              ParseForm: { kind: "method" },
+              ParseMultipartForm: { kind: "method" },
+              PathValue: { kind: "method" },
+              PostFormValue: { kind: "method" },
+              ProtoAtLeast: { kind: "method" },
+              Referer: { kind: "method" },
+              SetBasicAuth: { kind: "method" },
+              SetPathValue: { kind: "method" },
+              UserAgent: { kind: "method" },
+              WithContext: { kind: "method" },
+              Write: { kind: "method" },
+              WriteProxy: { kind: "method" },
+            },
+          },
+          NewRequest: { kind: "function" },
+          NewRequestWithContext: { kind: "function" },
+          ReadRequest: { kind: "function" },
+          Response: {
+            kind: "struct",
+            members: {
+              Status: { kind: "field" },
+              StatusCode: { kind: "field" },
+              Proto: { kind: "field" },
+              ProtoMajor: { kind: "field" },
+              ProtoMinor: { kind: "field" },
+              Header: { kind: "field" },
+              Body: { kind: "field" },
+              ContentLength: { kind: "field" },
+              TransferEncoding: { kind: "field" },
+              Close: { kind: "field" },
+              Uncompressed: { kind: "field" },
+              Trailer: { kind: "field" },
+              Request: { kind: "field" },
+              TLS: { kind: "field" },
+              Cookies: { kind: "method" },
+              Location: { kind: "method" },
+              ProtoAtLeast: { kind: "method" },
+              Write: { kind: "method" },
+            },
+          },
+          Get: { kind: "function" },
+          Head: { kind: "function" },
+          Post: { kind: "function" },
+          PostForm: { kind: "function" },
+          ReadResponse: { kind: "function" },
+          ResponseController: {
+            kind: "struct",
+            members: {
+              EnableFullDuplex: { kind: "method" },
+              Flush: { kind: "method" },
+              Hijack: { kind: "method" },
+              SetReadDeadline: { kind: "method" },
+              SetWriteDeadline: { kind: "method" },
+            },
+          },
+          NewResponseController: { kind: "function" },
+          ResponseWriter: {
+            kind: "interface",
+            members: {
+              Header: { kind: "field" },
+              Write: { kind: "field" },
+              WriteHeader: { kind: "field" },
+            },
+          },
+          RoundTripper: {
+            kind: "interface",
+            members: {
+              RoundTrip: { kind: "field" },
+            },
+          },
+          DefaultTransport: { kind: "var" },
+          NewFileTransport: { kind: "function" },
+          SameSite: { kind: "type", members: {} },
+          SameSiteDefaultMode: { kind: "var" },
+          SameSiteLaxMode: { kind: "var" },
+          SameSiteStrictMode: { kind: "var" },
+          SameSiteNoneMode: { kind: "var" },
+          ServeMux: {
+            kind: "struct",
+            members: {
+              Handle: { kind: "method" },
+              HandleFunc: { kind: "method" },
+              Handler: { kind: "method" },
+              ServeHTTP: { kind: "method" },
+            },
+          },
+          NewServeMux: { kind: "function" },
+          Server: {
+            kind: "struct",
+            members: {
+              Addr: { kind: "field" },
+              Handler: { kind: "field" },
+              DisableGeneralOptionsHandler: { kind: "field" },
+              TLSConfig: { kind: "field" },
+              ReadTimeout: { kind: "field" },
+              ReadHeaderTimeout: { kind: "field" },
+              WriteTimeout: { kind: "field" },
+              IdleTimeout: { kind: "field" },
+              MaxHeaderBytes: { kind: "field" },
+              TLSNextProto: { kind: "field" },
+              ConnState: { kind: "field" },
+              ErrorLog: { kind: "field" },
+              BaseContext: { kind: "field" },
+              ConnContext: { kind: "field" },
+              HTTP2: { kind: "field" },
+              Protocols: { kind: "field" },
+              Close: { kind: "method" },
+              ListenAndServe: { kind: "method" },
+              ListenAndServeTLS: { kind: "method" },
+              RegisterOnShutdown: { kind: "method" },
+              Serve: { kind: "method" },
+              ServeTLS: { kind: "method" },
+              SetKeepAlivesEnabled: { kind: "method" },
+              Shutdown: { kind: "method" },
+            },
+          },
+          Transport: {
+            kind: "struct",
+            members: {
+              Proxy: { kind: "field" },
+              OnProxyConnectResponse: { kind: "field" },
+              DialContext: { kind: "field" },
+              Dial: { kind: "field" },
+              DialTLSContext: { kind: "field" },
+              DialTLS: { kind: "field" },
+              TLSClientConfig: { kind: "field" },
+              TLSHandshakeTimeout: { kind: "field" },
+              DisableKeepAlives: { kind: "field" },
+              DisableCompression: { kind: "field" },
+              MaxIdleConns: { kind: "field" },
+              MaxIdleConnsPerHost: { kind: "field" },
+              MaxConnsPerHost: { kind: "field" },
+              IdleConnTimeout: { kind: "field" },
+              ResponseHeaderTimeout: { kind: "field" },
+              ExpectContinueTimeout: { kind: "field" },
+              TLSNextProto: { kind: "field" },
+              ProxyConnectHeader: { kind: "field" },
+              GetProxyConnectHeader: { kind: "field" },
+              MaxResponseHeaderBytes: { kind: "field" },
+              WriteBufferSize: { kind: "field" },
+              ReadBufferSize: { kind: "field" },
+              ForceAttemptHTTP2: { kind: "field" },
+              HTTP2: { kind: "field" },
+              Protocols: { kind: "field" },
+              CancelRequest: { kind: "method" },
+              Clone: { kind: "method" },
+              CloseIdleConnections: { kind: "method" },
+              RegisterProtocol: { kind: "method" },
+              RoundTrip: { kind: "method" },
+            },
+          },
+        },
+      },
+    },
+  } satisfies StrictDescriptor,
+  true,
+);

package/src/components/ImportStatement.tsx

@@ -0,0 +1,115 @@
+import { computed, For, Indent, memo } from "@alloy-js/core";
+import { basename, join, sep } from "pathe";
+import { useModule } from "../scopes/module.js";
+import { ImportRecords } from "../scopes/source-file.js";
+import { GoSymbol } from "../symbols/go.js";
+
+export interface ImportStatementProps {
+  path: string;
+  local?: boolean;
+  package?: GoSymbol;
+  dot?: boolean;
+  blank?: boolean;
+}
+
+export interface ImportStatementsProps {
+  records: ImportRecords;
+}
+
+export function ImportStatements(props: ImportStatementsProps) {
+  // TODO: allow for manual imports and . imports
+  const imports = computed(() => {
+    const module = useModule();
+    const moduleName = module?.name;
+    const builtins: ImportStatementProps[] = [];
+    const thirdParty: ImportStatementProps[] = [];
+    const local: ImportStatementProps[] = [];
+    for (const [pkg, sym] of props.records) {
+      const importPath = pkg.fullyQualifiedName;
+      if (moduleName && importPath.startsWith(moduleName + sep)) {
+        local.push({
+          path: importPath,
+          package: sym,
+        });
+      } else if (pkg.builtin) {
+        builtins.push({
+          path: importPath,
+          package: sym,
+        });
+      } else {
+        thirdParty.push({
+          path: importPath,
+          package: sym,
+        });
+      }
+    }
+    local.sort((a, b) => a.path.localeCompare(b.path));
+    thirdParty.sort((a, b) => a.path.localeCompare(b.path));
+    builtins.sort((a, b) => a.path.localeCompare(b.path));
+    const result: (ImportStatementProps | null)[] = [];
+    result.push(...builtins);
+    if (result.length > 0 && thirdParty.length > 0) {
+      result.push(null);
+    }
+    result.push(...thirdParty);
+    if (result.length > 0 && local.length > 0) {
+      result.push(null);
+    }
+    result.push(...local);
+    return result;
+  });
+
+  const rendered = memo(() => {
+    if (imports.value.length > 1) {
+      return (
+        <>
+          import (
+          <Indent hardline>
+            <For each={imports}>
+              {(imp) => (imp === null ? <></> : <ImportStatement {...imp} />)}
+            </For>
+          </Indent>
+          <hbr />)
+        </>
+      );
+    } else if (imports.value.length === 1 && imports.value[0] !== null) {
+      return <SingleImportStatement {...imports.value[0]} />;
+    } else {
+      return null;
+    }
+  });
+
+  return <>{rendered}</>;
+}
+
+function ImportStatement(props: ImportStatementProps) {
+  return memo(() => {
+    const module = useModule();
+    if (props.local) {
+      if (!module)
+        throw new Error("cannot import local package without module defined");
+      props.path = join(module.name, props.path);
+    }
+
+    const parts: string[] = [];
+    if (props.blank) {
+      parts.push("_ ");
+    } else if (props.dot) {
+      parts.push(". ");
+    } else if (props.package) {
+      if (props.package.name !== basename(props.path)) {
+        parts.push(props.package.name + " ");
+      }
+    }
+    parts.push(`"${props.path}"`);
+    return parts;
+  });
+}
+
+export function SingleImportStatement(props: ImportStatementProps) {
+  return (
+    <>
+      import <ImportStatement {...props} />
+    </>
+  );
+}

package/src/components/ModuleDirectory.tsx

@@ -0,0 +1,18 @@
+import { Children, Scope, SourceDirectory } from "@alloy-js/core";
+import { createGoModuleScope } from "../scopes/module.js";
+
+export interface ModuleDirectoryProps {
+  children?: Children;
+  name: string;
+  path?: string;
+}
+
+export function ModuleDirectory(props: ModuleDirectoryProps) {
+  const moduleScope = createGoModuleScope(props.name);
+
+  return (
+    <SourceDirectory path={props.path ?? "."}>
+      <Scope value={moduleScope}>{props.children}</Scope>
+    </SourceDirectory>
+  );
+}

package/src/components/Name.tsx

@@ -0,0 +1,11 @@
+import { DeclarationContext, useContext } from "@alloy-js/core";
+
+// the name within the current declaration
+export function Name() {
+  const declSymbol = useContext(DeclarationContext);
+  if (!declSymbol) {
+    throw new Error("missing declaration context");
+  }
+
+  return <>{declSymbol.name}</>;
+}

package/src/components/Reference.tsx

@@ -0,0 +1,18 @@
+import { computed, emitSymbol, Refkey } from "@alloy-js/core";
+import { ref } from "../symbols/index.js";
+
+export interface ReferenceProps {
+  refkey: Refkey;
+}
+
+// used to resolve refkey references within source files
+export function Reference({ refkey }: ReferenceProps) {
+  const reference = ref(refkey);
+
+  const computedRef = computed(() => reference());
+  if (computedRef.value[1]) {
+    emitSymbol(computedRef.value[1]);
+  }
+
+  return <>{computedRef.value[0]}</>;
+}