Add Try statement to typescript (#349)

Author: bterlson

.chronus/changes/try-statement-2026-0-8-12-51-23.md

@@ -0,0 +1,7 @@
+---
+changeKind: feature
+packages:
+  - "@alloy-js/typescript"
+---
+
+Add TryStatement, CatchClause, and FinallyClause components.

.chronus/changes/try-statement-2026-0-8-12-51-47.md

@@ -0,0 +1,7 @@
+---
+changeKind: fix
+packages:
+  - "@alloy-js/typescript"
+---
+
+IfElseClause and ElseClause properly create block scopes.

packages/typescript/src/components/IfStatement.tsx

@@ -1,4 +1,4 @@
-import { Block, type Children } from "@alloy-js/core";
+import { type Children } from "@alloy-js/core";
 import { BlockScope } from "./BlockScope.jsx";
 
 export interface IfStatementProps {
@@ -29,7 +29,7 @@ export function ElseIfClause(props: ElseIfClauseProps) {
   return (
     <>
       {" "}
-      else if ({props.condition}) <Block>{props.children}</Block>
+      else if ({props.condition}) <BlockScope>{props.children}</BlockScope>
     </>
   );
 }
@@ -45,7 +45,7 @@ export function ElseClause(props: ElseClauseProps) {
   return (
     <>
       {" "}
-      else <Block>{props.children}</Block>
+      else <BlockScope>{props.children}</BlockScope>
     </>
   );
 }

packages/typescript/src/components/TryStatement.test.tsx

@@ -0,0 +1,123 @@
+import { refkey, StatementList } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { toSourceText } from "../../test/utils.jsx";
+import { CatchClause, FinallyClause, TryStatement } from "./TryStatement.jsx";
+import { VarDeclaration } from "./VarDeclaration.jsx";
+
+it("works with try-catch", () => {
+  const text = toSourceText(
+    <>
+      <TryStatement>// try something</TryStatement>
+      <CatchClause parameter="error">// handle error</CatchClause>
+    </>,
+  );
+
+  expect(text).toBe(d`
+    try {
+      // try something
+    } catch (error) {
+      // handle error
+    }
+  `);
+});
+
+it("works with try-catch-finally", () => {
+  const text = toSourceText(
+    <>
+      <TryStatement>// try something</TryStatement>
+      <CatchClause parameter="error">// handle error</CatchClause>
+      <FinallyClause>// cleanup</FinallyClause>
+    </>,
+  );
+
+  expect(text).toBe(d`
+    try {
+      // try something
+    } catch (error) {
+      // handle error
+    } finally {
+      // cleanup
+    }
+  `);
+});
+
+it("works with try-finally", () => {
+  const text = toSourceText(
+    <>
+      <TryStatement>// try something</TryStatement>
+      <FinallyClause>// cleanup</FinallyClause>
+    </>,
+  );
+
+  expect(text).toBe(d`
+    try {
+      // try something
+    } finally {
+      // cleanup
+    }
+  `);
+});
+
+it("works with catch without parameter", () => {
+  const text = toSourceText(
+    <>
+      <TryStatement>// try something</TryStatement>
+      <CatchClause>// handle error without parameter</CatchClause>
+    </>,
+  );
+
+  expect(text).toBe(d`
+    try {
+      // try something
+    } catch {
+      // handle error without parameter
+    }
+  `);
+});
+
+it("works with typed catch parameter", () => {
+  const text = toSourceText(
+    <>
+      <TryStatement>// try something</TryStatement>
+      <CatchClause parameter={{ name: "error", type: "Error" }}>
+        // handle typed error
+      </CatchClause>
+    </>,
+  );
+
+  expect(text).toBe(d`
+    try {
+      // try something
+    } catch (error: Error) {
+      // handle typed error
+    }
+  `);
+});
+
+it("creates symbols for catch parameters", () => {
+  const rk = refkey();
+
+  const text = toSourceText(
+    <>
+      <TryStatement>// try something</TryStatement>
+      <CatchClause parameter={{ name: "error", type: "Error", refkey: rk }}>
+        <StatementList>
+          {rk}
+          <VarDeclaration name="message" type="string">
+            {rk}.message
+          </VarDeclaration>
+        </StatementList>
+      </CatchClause>
+    </>,
+  );
+
+  expect(text).toBe(d`
+    try {
+      // try something
+    } catch (error: Error) {
+      error;
+      const message: string = error.message;
+    }
+  `);
+});

packages/typescript/src/components/TryStatement.tsx

@@ -0,0 +1,141 @@
+import { onCleanup, type Children } from "@alloy-js/core";
+import { useTSNamePolicy } from "../name-policy.js";
+import type { ParameterDescriptor } from "../parameter-descriptor.js";
+import { createValueSymbol, TSSymbolFlags } from "../symbols/index.js";
+import { BlockScope } from "./BlockScope.jsx";
+
+export interface TryStatementProps {
+  children: Children;
+}
+
+/**
+ * A try statement.
+ *
+ * @example
+ * ```tsx
+ * <TryStatement>
+ *   // risky operation
+ * </TryStatement>
+ * <CatchClause parameter="error">
+ *   console.error(error);
+ * </CatchClause>
+ * ```
+ * renders to
+ * ```ts
+ * try {
+ *   // risky operation
+ * } catch (error) {
+ *   console.error(error);
+ * }
+ * ```
+ */
+export function TryStatement(props: TryStatementProps) {
+  return (
+    <>
+      try <BlockScope>{props.children}</BlockScope>
+    </>
+  );
+}
+
+export interface CatchClauseProps {
+  parameter?: ParameterDescriptor | string;
+  children: Children;
+}
+
+/**
+ * A catch clause of a try statement.
+ *
+ * @example
+ * ```tsx
+ * <CatchClause parameter={{ name: "error", type: "unknown" }}>
+ *   console.error(error);
+ * </CatchClause>
+ * ```
+ * renders to
+ * ```ts
+ * catch (error: unknown) {
+ *   console.error(error);
+ * }
+ * ```
+ *
+ * @remarks
+ * The parameter can be omitted for a catch-all clause, or provided as a string
+ * or {@link ParameterDescriptor}. When using a descriptor, a refkey can be provided
+ * to reference the parameter within the catch block. Note that TypeScript only allows
+ * `any` or `unknown` as catch parameter types.
+ */
+export function CatchClause(props: CatchClauseProps) {
+  if (!props.parameter) {
+    return (
+      <>
+        {" "}
+        catch <BlockScope>{props.children}</BlockScope>
+      </>
+    );
+  }
+
+  const namePolicy = useTSNamePolicy();
+  const paramDesc =
+    typeof props.parameter === "string" ?
+      { name: props.parameter }
+    : props.parameter;
+
+  const symbol = createValueSymbol(paramDesc.name, {
+    refkeys: paramDesc.refkey,
+    tsFlags: TSSymbolFlags.ParameterSymbol,
+    metadata: paramDesc.metadata,
+    namePolicy: namePolicy.for("parameter"),
+  });
+
+  onCleanup(() => {
+    symbol.delete();
+  });
+
+  const param = (
+    <>
+      {symbol.name}
+      {paramDesc.type && <>: {paramDesc.type}</>}
+    </>
+  );
+
+  return (
+    <>
+      {" "}
+      catch ({param}) <BlockScope>{props.children}</BlockScope>
+    </>
+  );
+}
+
+export interface FinallyClauseProps {
+  children: Children;
+}
+
+/**
+ * A finally clause of a try statement.
+ *
+ * @example
+ * ```tsx
+ * <TryStatement>
+ *   // risky operation
+ * </TryStatement>
+ * <FinallyClause>
+ *   // cleanup
+ * </FinallyClause>
+ * ```
+ * renders to
+ * ```ts
+ * try {
+ *   // risky operation
+ * } finally {
+ *   // cleanup
+ * }
+ * ```
+ */
+export function FinallyClause(props: FinallyClauseProps) {
+  return (
+    <>
+      {" "}
+      finally <BlockScope>{props.children}</BlockScope>
+    </>
+  );
+}

packages/typescript/src/components/index.ts

@@ -35,6 +35,7 @@ export * from "./Reference.js";
 export * from "./SingleLineCommentBlock.jsx";
 export * from "./SourceFile.js";
 export * from "./SwitchStatement.jsx";
+export * from "./TryStatement.jsx";
 export * from "./TsConfigJson.js";
 export * from "./TypeDeclaration.js";
 export * from "./TypeRefContext.jsx";