@alloy-js/csharp 0.18.0-dev.8 → 0.18.0

package/src/components/ClassDeclaration.tsx

@@ -1,4 +1,5 @@
 import * as core from "@alloy-js/core";
+import { join } from "@alloy-js/core";
 import {
   AccessModifiers,
   computeModifiersPrefix,
@@ -8,9 +9,13 @@ import {
 import { CSharpElements, useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
-import { Name } from "./Name.jsx";
-import { ParameterProps, Parameters } from "./Parameters.jsx";
+import { AttributeList, AttributesProp } from "./attributes/attributes.jsx";
 import { DocWhen } from "./doc/comment.jsx";
+import { Name } from "./Name.jsx";
+import { ParameterProps, Parameters } from "./parameters/parameters.jsx";
+import { TypeParameterConstraints } from "./type-parameters/type-parameter-constraints.jsx";
+import { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
+import { TypeParameters } from "./type-parameters/type-parameters.jsx";
 
 export interface ClassModifiers {
   readonly abstract?: boolean;
@@ -35,7 +40,44 @@ export interface ClassDeclarationProps
   /** Doc comment */
   doc?: core.Children;
   refkey?: core.Refkey;
-  typeParameters?: Record<string, core.Refkey>;
+
+  /**
+   * Type parameters for the class
+   *
+   * @example
+   * ```tsx
+   * <ClassDeclaration name="MyClass" typeParameters={["T"]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * public class MyClass<T>
+   * ```
+   */
+  typeParameters?: (string | TypeParameterProps)[];
+
+  /** Base class that this class extends */
+  baseType?: core.Children;
+
+  /** Interfaces this class implements */
+  interfaceTypes?: core.Children[];
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <ClassDeclaration name="MyClass" attributes={[
+   *  <Attribute name="Test" />
+   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
+   * ]}>
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test]
+   * [Test2("arg1", "arg2")]
+   * public class MyClass
+   * ```
+   */
+  attributes?: AttributesProp;
 }
 
 /**
@@ -77,31 +119,12 @@ export function ClassDeclaration(props: ClassDeclarationProps) {
     owner: thisClassSymbol,
   });
 
-  let typeParams: core.Children;
-  if (props.typeParameters) {
-    const typeParamNames = new Array<string>();
-    for (const entry of Object.entries(props.typeParameters)) {
-      typeParamNames.push(
-        useCSharpNamePolicy().getName(entry[0], "type-parameter"),
-      );
-      // create a symbol for each type param so its
-      // refkey resolves to the type param's name
-      new CSharpOutputSymbol(entry[0], {
-        scope: thisClassScope,
-        refkeys: entry[1],
-      });
-    }
-    typeParams = (
-      <group>
-        {"<"}
-        <core.For each={typeParamNames} comma line>
-          {(name) => name}
-        </core.For>
-        {">"}
-      </group>
-    );
-  }
-
+  const bases = [
+    ...(props.baseType ? [props.baseType] : []),
+    ...(props.interfaceTypes || []),
+  ];
+  const base =
+    bases.length > 0 ? <> : {join(bases, { joiner: ", " })}</> : null;
   const modifiers = computeModifiersPrefix([
     getAccessModifier(props),
     getClassModifiers(props),
@@ -109,8 +132,15 @@ export function ClassDeclaration(props: ClassDeclarationProps) {
   return (
     <core.Declaration symbol={thisClassSymbol}>
       <DocWhen doc={props.doc} />
+      <AttributeList attributes={props.attributes} endline />
       {modifiers}class <Name />
-      {typeParams}
+      {props.typeParameters && (
+        <TypeParameters parameters={props.typeParameters} />
+      )}
+      {base}
+      {props.typeParameters && (
+        <TypeParameterConstraints parameters={props.typeParameters} />
+      )}
       {!props.children && ";"}
       {props.children && (
         <core.Block newline>
@@ -151,15 +181,14 @@ export function ClassConstructor(props: ClassConstructorProps) {
 
   const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
 
-  const params =
-    props.parameters ? <Parameters parameters={props.parameters} /> : "";
-
   // note that scope wraps the ctor decl so that the params get the correct scope
   return (
     <core.Declaration symbol={ctorSymbol}>
       <core.Scope value={ctorDeclScope}>
         {modifiers}
-        <Name />({params})<core.Block newline>{props.children}</core.Block>
+        <Name />
+        <Parameters parameters={props.parameters} />
+        <core.Block newline>{props.children}</core.Block>
       </core.Scope>
     </core.Declaration>
   );
@@ -170,6 +199,8 @@ export interface ClassMemberProps extends AccessModifiers {
   name: string;
   type: core.Children;
   refkey?: core.Refkey;
+  /** Doc comment */
+  doc?: core.Children;
 }
 
 // a C# class member (i.e. a field within a class like "private int count")
@@ -194,6 +225,7 @@ export function ClassMember(props: ClassMemberProps) {
   const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
   return (
     <core.Declaration symbol={memberSymbol}>
+      <DocWhen doc={props.doc} />
       {modifiers}
       {props.type} <Name />
     </core.Declaration>

package/src/components/ClassMethod.tsx

@@ -16,8 +16,12 @@ import {
 import { useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
-import { ParameterProps, Parameters } from "./Parameters.jsx";
+import { AttributeList, AttributesProp } from "./attributes/attributes.jsx";
 import { DocWhen } from "./doc/comment.jsx";
+import { ParameterProps, Parameters } from "./parameters/parameters.jsx";
+import { TypeParameterConstraints } from "./type-parameters/type-parameter-constraints.jsx";
+import { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
+import { TypeParameters } from "./type-parameters/type-parameters.jsx";
 
 /** Method modifiers. Can only be one. */
 export interface ClassMethodModifiers {
@@ -51,6 +55,38 @@ export interface ClassMethodProps
 
   /** Doc comment */
   doc?: Children;
+
+  /**
+   * Type parameters for the method
+   *
+   * @example
+   * ```tsx
+   * <InterfaceMethod name="Test" typeParameters={["T"]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * public void Test<T>()
+   * ```
+   */
+  typeParameters?: (TypeParameterProps | string)[];
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <ClassMethod name="MyMethod" attributes={[
+   *  <Attribute name="Test" />
+   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
+   * ]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test]
+   * [Test2("arg1", "arg2")]
+   * public void MyMethod() { }
+   * ```
+   */
+  attributes?: AttributesProp;
 }
 
 // a C# class method
@@ -71,8 +107,6 @@ export function ClassMethod(props: ClassMethodProps) {
     owner: methodSymbol,
   });
 
-  const params =
-    props.parameters ? <Parameters parameters={props.parameters} /> : "";
   const returns = props.returns ?? (props.async ? "Task" : "void");
 
   const modifiers = computeModifiersPrefix([
@@ -85,8 +119,16 @@ export function ClassMethod(props: ClassMethodProps) {
     <MemberDeclaration symbol={methodSymbol}>
       <Scope value={methodScope}>
         <DocWhen doc={props.doc} />
+        <AttributeList attributes={props.attributes} endline />
         {modifiers}
-        {returns} {name}({params})
+        {returns} {name}
+        {props.typeParameters && (
+          <TypeParameters parameters={props.typeParameters} />
+        )}
+        <Parameters parameters={props.parameters} />
+        {props.typeParameters && (
+          <TypeParameterConstraints parameters={props.typeParameters} />
+        )}
         {props.abstract ? ";" : <Block newline>{props.children}</Block>}
       </Scope>
     </MemberDeclaration>

package/src/components/SourceFile.tsx

@@ -58,6 +58,7 @@ export function SourceFile(props: SourceFileProps) {
       filetype="cs"
       reference={Reference}
       tabWidth={4}
+      printWidth={120}
     >
       <SourceFileContext.Provider value={sourceFileCtx}>
         <core.Scope name={props.path} kind="source-file">

package/src/components/attributes/attributes.test.tsx

@@ -0,0 +1,61 @@
+import { expect, it } from "vitest";
+import { Attribute, AttributeList } from "./attributes.jsx";
+
+it("define attribute", () => {
+  expect(<Attribute name="Test" />).toRenderTo(`
+      [Test]
+  `);
+});
+
+it("define attribute with single arg", () => {
+  expect(<Attribute name="Test" args={[`"abc"`]} />).toRenderTo(`
+      [Test("abc")]
+  `);
+});
+
+it("define attribute with multiple arg", () => {
+  expect(<Attribute name="Test" args={[`"abc"`, `"def"`]} />).toRenderTo(`
+      [Test("abc", "def")]
+  `);
+});
+
+it("define attribute list with Attribute components", () => {
+  expect(
+    <AttributeList
+      attributes={[<Attribute name="TestA" />, <Attribute name="TestB" />]}
+    />,
+  ).toRenderTo(`
+      [TestA]
+      [TestB]
+  `);
+});
+
+it("define attribute list with attribute names", () => {
+  expect(<AttributeList attributes={["TestA", "TestB"]} />).toRenderTo(`
+      [TestA]
+      [TestB]
+  `);
+});
+
+it("define attribute list with attribute props", () => {
+  expect(
+    <AttributeList
+      attributes={[{ name: "TestA" }, { name: "TestB", args: [`"test"`] }]}
+    />,
+  ).toRenderTo(`
+      [TestA]
+      [TestB("test")]
+  `);
+});
+
+it("define attribute list with children", () => {
+  expect(
+    <AttributeList>
+      <Attribute name="TestA" />
+      <Attribute name="TestB" />
+    </AttributeList>,
+  ).toRenderTo(`
+      [TestA]
+      [TestB]
+  `);
+});

package/src/components/attributes/attributes.tsx

@@ -0,0 +1,100 @@
+import {
+  Children,
+  findKeyedChildren,
+  For,
+  Indent,
+  taggedComponent,
+} from "@alloy-js/core";
+
+export interface AttributeItem {
+  name: string;
+  args?: string[];
+}
+
+export type AttributesProp = Array<string | AttributeProps | Children>;
+
+export interface AttributeListProps {
+  /** If the attribute list should finish with a hard line if there is any attribute */
+  endline?: boolean;
+  attributes?: AttributesProp;
+  children?: Children[];
+}
+
+/**
+ * Render each attributes in a new line.
+ */
+export function AttributeList(props: AttributeListProps) {
+  const attributes =
+    props.attributes ??
+    (props.children && findKeyedChildren(props.children, Attribute.tag));
+
+  if (!attributes) {
+    return null;
+  }
+
+  return (
+    <>
+      <For each={attributes} line>
+        {(arg) => renderAttribute(arg)}
+      </For>
+      {props.endline && attributes.length > 0 && <hbr />}
+    </>
+  );
+}
+
+function renderAttribute(attr: string | AttributeProps | Children): Children {
+  if (typeof attr === "string") {
+    return <Attribute name={attr} />;
+  } else if (typeof attr === "object" && attr && "name" in attr) {
+    return <Attribute {...attr} />;
+  } else {
+    return attr;
+  }
+}
+
+export interface AttributeProps {
+  /** Attribute name */
+  name: Children;
+
+  /** Argument */
+  args?: Children[];
+}
+
+const AttributeTag = Symbol("AttributeTag");
+/**
+ * Render a csharp attribute.
+ *
+ * @example
+ * ```tsx
+ * <Attribute name="Test" /><hbr/>
+ * <Attribute name="Test" args={["arg1", "arg2"]} />
+ * ```
+ *
+ * will render:
+ * ```csharp
+ * [Test]
+ * [Test("arg1", "arg2")]
+ * ```
+ */
+export const Attribute = taggedComponent(
+  AttributeTag,
+  (props: AttributeProps) => {
+    return (
+      <group>
+        [{props.name}
+        {props.args && props.args.length > 0 && (
+          <>
+            (
+            <Indent softline>
+              <For each={props.args ?? []} comma line>
+                {(arg) => arg}
+              </For>
+            </Indent>
+            )
+          </>
+        )}
+        ]
+      </group>
+    );
+  },
+);

package/src/components/doc/comment.test.tsx

@@ -1,26 +1,22 @@
-import { expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import {
   DocC,
   DocCode,
   DocComment,
-  DocCompletionList,
   DocDescription,
   DocExample,
   DocException,
   DocInclude,
-  DocItem,
   DocList,
   DocPara,
   DocParam,
   DocParamRef,
   DocPermission,
   DocRemarks,
-  DocResponse,
   DocReturns,
   DocSee,
   DocSeeAlso,
   DocSummary,
-  DocTerm,
   DocTypeParam,
   DocTypeParamRef,
   DocValue,
@@ -56,9 +52,7 @@ it("define c", () => {
       <DocC>inline code</DocC>
     </DocComment>,
   ).toRenderTo(`
-    /// <c>
-    /// inline code
-    /// </c>
+    /// <c>inline code</c>
   `);
 });
 
@@ -89,7 +83,7 @@ it("define exception", () => {
 it("define include", () => {
   expect(
     <DocComment>
-      <>{DocInclude({ file: "external.xml", path: "/doc/summary" })}</>
+      <DocInclude file="external.xml" path="/doc/summary" />
     </DocComment>,
   ).toRenderTo(`
     /// <include file="external.xml" path="/doc/summary" />
@@ -164,66 +158,20 @@ it("define permission", () => {
   `);
 });
 
-it("define response", () => {
-  expect(
-    <DocComment>
-      <DocResponse>response info</DocResponse>
-    </DocComment>,
-  ).toRenderTo(`
-    /// <response>
-    /// response info
-    /// </response>
-  `);
-});
-
-it("define completionlist", () => {
-  expect(
-    <DocComment>
-      <DocCompletionList>completion list</DocCompletionList>
-    </DocComment>,
-  ).toRenderTo(`
-    /// <completionlist>
-    /// completion list
-    /// </completionlist>
-  `);
-});
-
 it("define list", () => {
   expect(
     <DocComment>
-      <DocList>list content</DocList>
+      <DocList type="bullet" items={["item 1", "item 2", "item 3"]} />
     </DocComment>,
   ).toRenderTo(`
-    /// <list>
-    /// list content
+    /// <list type="bullet">
+    ///   <item><description>item 1</description></item>
+    ///   <item><description>item 2</description></item>
+    ///   <item><description>item 3</description></item>
     /// </list>
   `);
 });
 
-it("define item", () => {
-  expect(
-    <DocComment>
-      <DocItem>item content</DocItem>
-    </DocComment>,
-  ).toRenderTo(`
-    /// <item>
-    /// item content
-    /// </item>
-  `);
-});
-
-it("define term", () => {
-  expect(
-    <DocComment>
-      <DocTerm>term content</DocTerm>
-    </DocComment>,
-  ).toRenderTo(`
-    /// <term>
-    /// term content
-    /// </term>
-  `);
-});
-
 it("define description", () => {
   expect(
     <DocComment>
@@ -248,40 +196,93 @@ it("define para", () => {
   `);
 });
 
-it("define see", () => {
-  expect(
-    <DocComment>
-      <>{DocSee({ cref: "T:MyType" })}</>
-    </DocComment>,
-  ).toRenderTo(`
-    /// <see cref="T:MyType" />
-  `);
+describe("define see", () => {
+  it("with cref", () => {
+    expect(
+      <DocComment>
+        <DocSee cref="T:MyType" />
+      </DocComment>,
+    ).toRenderTo(`
+      /// <see cref="T:MyType" />
+    `);
+  });
+
+  it("with href", () => {
+    expect(
+      <DocComment>
+        <DocSee href="https://github.com" />
+      </DocComment>,
+    ).toRenderTo(`
+      /// <see href="https://github.com" />
+    `);
+  });
+  it("with href and children", () => {
+    expect(
+      <DocComment>
+        <DocSee href="https://github.com">GitHub</DocSee>
+      </DocComment>,
+    ).toRenderTo(`
+      /// <see href="https://github.com">GitHub</see>
+    `);
+  });
+
+  it("with langword", () => {
+    expect(
+      <DocComment>
+        <DocSee langword="keyword" />
+      </DocComment>,
+    ).toRenderTo(`
+      /// <see langword="keyword" />
+    `);
+  });
 });
 
-it("define seealso", () => {
-  expect(
-    <DocComment>
-      <>{DocSeeAlso({ cref: "T:OtherType" })}</>
-    </DocComment>,
-  ).toRenderTo(`
-    /// <seealso cref="T:OtherType" />
-  `);
+describe("define seealso", () => {
+  it("with cref", () => {
+    expect(
+      <DocComment>
+        <DocSeeAlso cref="T:OtherType" />
+      </DocComment>,
+    ).toRenderTo(`
+      /// <seealso cref="T:OtherType" />
+    `);
+  });
+
+  it("with href", () => {
+    expect(
+      <DocComment>
+        <DocSeeAlso href="https://github.com" />
+      </DocComment>,
+    ).toRenderTo(`
+      /// <seealso href="https://github.com" />
+    `);
+  });
+
+  it("with children", () => {
+    expect(
+      <DocComment>
+        <DocSeeAlso cref="T:OtherType">OtherType</DocSeeAlso>
+      </DocComment>,
+    ).toRenderTo(`
+      /// <seealso cref="T:OtherType">OtherType</seealso>
+    `);
+  });
 });
 
 it("define paramref", () => {
   expect(
     <DocComment>
-      <>{DocParamRef({ name: "x" })}</>
+      <DocParamRef name="x" />
     </DocComment>,
   ).toRenderTo(`
-    /// <paramref name="x" />
+    /// <paramref name="${"x"}" />
   `);
 });
 
 it("define typeparamref", () => {
   expect(
     <DocComment>
-      <>{DocTypeParamRef({ name: "T" })}</>
+      <DocTypeParamRef name="T" />
     </DocComment>,
   ).toRenderTo(`
     /// <typeparamref name="T" />