@alloy-js/csharp 0.18.0-dev.9 → 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/index.ts

@@ -1,3 +1,4 @@
+export * from "./attributes/attributes.jsx";
 export * from "./ClassDeclaration.jsx";
 export * from "./ClassMethod.jsx";
 export * from "./Declaration.js";
@@ -6,10 +7,15 @@ export * from "./doc/from-markdown.jsx";
 export * from "./EnumDeclaration.jsx";
 export * from "./interface/declaration.js";
 export * from "./interface/method.js";
+export * from "./interface/property.js";
 export * from "./Name.js";
 export * from "./Namespace.js";
-export * from "./Parameters.js";
+export * from "./parameters/parameters.jsx";
 export * from "./ProjectDirectory.js";
+export * from "./property/property.jsx";
+export * from "./record/declaration.js";
 export * from "./Reference.js";
 export * from "./SourceFile.js";
+export type { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
 export * from "./UsingDirective.js";
+export * from "./var/declaration.jsx";

package/src/components/interface/declaration.test.tsx

@@ -1,6 +1,11 @@
+import { List, refkey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
+import { Attribute } from "../attributes/attributes.jsx";
+import { SourceFile } from "../SourceFile.jsx";
+import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { InterfaceDeclaration } from "./declaration.jsx";
+import { InterfaceProperty } from "./property.jsx";
 
 it("declares class with no members", () => {
   expect(
@@ -54,3 +59,100 @@ it("specify doc comment", () => {
     interface TestInterface;
   `);
 });
+
+describe("with type parameters", () => {
+  it("reference parameters", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        refkey: refkey(),
+      },
+      {
+        name: "U",
+        refkey: refkey(),
+      },
+    ];
+
+    expect(
+      <TestNamespace>
+        <SourceFile path="Test.cs">
+          <InterfaceDeclaration
+            public
+            name="Test"
+            typeParameters={typeParameters}
+          >
+            <List>
+              <InterfaceProperty
+                name="PropA"
+                type={typeParameters[0].refkey}
+                get
+                set
+              />
+              <InterfaceProperty
+                name="PropB"
+                type={typeParameters[1].refkey}
+                get
+                set
+              />
+            </List>
+          </InterfaceDeclaration>
+        </SourceFile>
+      </TestNamespace>,
+    ).toRenderTo(`
+      namespace TestCode
+      {
+        public interface Test<T, U>
+        {
+          T PropA { get; set; }
+          U PropB { get; set; }
+        }
+      }
+    `);
+  });
+
+  it("defines with constraints", () => {
+    const typeParameters: TypeParameterProps[] = [
+      {
+        name: "T",
+        constraints: "IFoo",
+      },
+      {
+        name: "U",
+        constraints: "IBar",
+      },
+    ];
+
+    expect(
+      <TestNamespace>
+        <InterfaceDeclaration
+          public
+          name="Test"
+          typeParameters={typeParameters}
+        >
+          // Body
+        </InterfaceDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      public interface Test<T, U>
+        where T : IFoo
+        where U : IBar
+      {
+        // Body
+      }
+    `);
+  });
+});
+
+it("specify attributes", () => {
+  expect(
+    <TestNamespace>
+      <InterfaceDeclaration
+        name="Test"
+        attributes={[<Attribute name="Test" />]}
+      />
+    </TestNamespace>,
+  ).toRenderTo(`
+    [Test]
+    interface Test;
+  `);
+});

package/src/components/interface/declaration.tsx

@@ -8,8 +8,12 @@ import {
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope } from "../../symbols/scopes.js";
+import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 import { Name } from "../Name.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 InterfaceModifiers {
   readonly partial?: boolean;
@@ -27,7 +31,38 @@ export interface InterfaceDeclarationProps
   /** Doc comment */
   doc?: core.Children;
   refkey?: core.Refkey;
-  typeParameters?: Record<string, core.Refkey>;
+
+  /**
+   * Type parameters for the interface
+   *
+   * @example
+   * ```tsx
+   * <InterfaceDeclaration name="IList" typeParameters={["T"]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * public interface IList<T>
+   * ```
+   */
+  typeParameters?: (TypeParameterProps | string)[];
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <InterfaceDeclaration name="MyInterface" attributes={[
+   *  <Attribute name="Test" />
+   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
+   * ]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test]
+   * [Test2("arg1", "arg2")]
+   * public interface MyInterface
+   * ```
+   */
+  attributes?: AttributesProp;
 }
 
 /**
@@ -65,31 +100,6 @@ export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
     owner: thisInterfaceSymbol,
   });
 
-  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: thisInterfaceScope,
-        refkeys: entry[1],
-      });
-    }
-    typeParams = (
-      <group>
-        {"<"}
-        <core.For each={typeParamNames} comma line>
-          {(name) => name}
-        </core.For>
-        {">"}
-      </group>
-    );
-  }
-
   const modifiers = computeModifiersPrefix([
     getAccessModifier(props),
     getInterfaceModifiers(props),
@@ -97,8 +107,14 @@ export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
   return (
     <core.Declaration symbol={thisInterfaceSymbol}>
       <DocWhen doc={props.doc} />
+      <AttributeList attributes={props.attributes} endline />
       {modifiers}interface <Name />
-      {typeParams}
+      {props.typeParameters && (
+        <TypeParameters parameters={props.typeParameters} />
+      )}
+      {props.typeParameters && (
+        <TypeParameterConstraints parameters={props.typeParameters} />
+      )}
       {props.children ?
         <core.Block newline>
           <core.Scope value={thisInterfaceScope}>{props.children}</core.Scope>