@alloy-js/csharp 0.18.0-dev.23 → 0.18.0-dev.24

package/src/components/ClassDeclaration.tsx

@@ -9,6 +9,7 @@ import {
 import { CSharpElements, useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
+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";
@@ -59,6 +60,24 @@ export interface ClassDeclarationProps
 
   /** 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;
 }
 
 /**
@@ -113,6 +132,7 @@ export function ClassDeclaration(props: ClassDeclarationProps) {
   return (
     <core.Declaration symbol={thisClassSymbol}>
       <DocWhen doc={props.doc} />
+      <AttributeList attributes={props.attributes} endline />
       {modifiers}class <Name />
       {props.typeParameters && (
         <TypeParameters parameters={props.typeParameters} />

package/src/components/ClassMethod.tsx

@@ -16,6 +16,7 @@ import {
 import { useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
+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";
@@ -68,6 +69,24 @@ export interface ClassMethodProps
    * ```
    */
   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
@@ -100,6 +119,7 @@ export function ClassMethod(props: ClassMethodProps) {
     <MemberDeclaration symbol={methodSymbol}>
       <Scope value={methodScope}>
         <DocWhen doc={props.doc} />
+        <AttributeList attributes={props.attributes} endline />
         {modifiers}
         {returns} {name}
         {props.typeParameters && (

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";

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

@@ -1,6 +1,7 @@
 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";
@@ -141,3 +142,17 @@ describe("with type parameters", () => {
     `);
   });
 });
+
+it("specify attributes", () => {
+  expect(
+    <TestNamespace>
+      <InterfaceDeclaration
+        name="Test"
+        attributes={[<Attribute name="Test" />]}
+      />
+    </TestNamespace>,
+  ).toRenderTo(`
+    [Test]
+    interface Test;
+  `);
+});

package/src/components/interface/declaration.tsx

@@ -8,6 +8,7 @@ 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";
@@ -44,6 +45,24 @@ export interface InterfaceDeclarationProps
    * ```
    */
   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;
 }
 
 /**
@@ -88,6 +107,7 @@ export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
   return (
     <core.Declaration symbol={thisInterfaceSymbol}>
       <DocWhen doc={props.doc} />
+      <AttributeList attributes={props.attributes} endline />
       {modifiers}interface <Name />
       {props.typeParameters && (
         <TypeParameters parameters={props.typeParameters} />

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

@@ -2,6 +2,7 @@ import { refkey } from "@alloy-js/core";
 import { Children } from "@alloy-js/core/jsx-runtime";
 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";
@@ -174,6 +175,20 @@ it("specify doc comment", () => {
   `);
 });
 
+it("specify attributes", () => {
+  expect(
+    <Wrapper>
+      <InterfaceMethod name="Test" attributes={[<Attribute name="Test" />]} />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+      [Test]
+      void Test();
+    }
+  `);
+});
+
 describe("with type parameters", () => {
   it("reference parameters", () => {
     const typeParameters: TypeParameterProps[] = [

package/src/components/interface/method.tsx

@@ -15,6 +15,7 @@ import {
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope, useCSharpScope } from "../../symbols/scopes.js";
+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";
@@ -53,6 +54,24 @@ export interface InterfaceMethodProps
 
   /** Doc comment */
   doc?: Children;
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <InterfaceMethod name="MyMethod" attributes={[
+   *  <Attribute name="Test" />
+   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
+   * ]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test]
+   * [Test2("arg1", "arg2")]
+   * void MyMethod();
+   * ```
+   */
+  attributes?: AttributesProp;
 }
 
 // a C# interface method
@@ -84,6 +103,7 @@ export function InterfaceMethod(props: InterfaceMethodProps) {
     <MemberDeclaration symbol={methodSymbol}>
       <Scope value={methodScope}>
         <DocWhen doc={props.doc} />
+        <AttributeList attributes={props.attributes} endline />
         {modifiers}
         {props.returns ?? "void"} {name}
         {props.typeParameters && (

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

@@ -1,6 +1,7 @@
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
+import { Attribute } from "../attributes/attributes.jsx";
 import { InterfaceDeclaration } from "./declaration.jsx";
 import { InterfaceProperty } from "./property.jsx";
 
@@ -142,3 +143,23 @@ it("specify doc comment", () => {
     }
   `);
 });
+
+it("specify attributes", () => {
+  expect(
+    <Wrapper>
+      <InterfaceProperty
+        name="Test"
+        type="int"
+        attributes={[<Attribute name="Test" />]}
+        get
+        set
+      />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+      [Test]
+      int Test { get; set; }
+    }
+  `);
+});

package/src/components/interface/property.tsx

@@ -16,6 +16,7 @@ import {
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope, useCSharpScope } from "../../symbols/scopes.js";
+import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 
 /** Method modifiers. Can only be one. */
@@ -53,6 +54,24 @@ export interface InterfacePropertyProps
    * ```
    */
   nullable?: boolean;
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <InterfaceProperty name="MyProp" attributes={[
+   *  <Attribute name="Test" />
+   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
+   * ]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test]
+   * [Test2("arg1", "arg2")]
+   * int MyProp { get; set; }
+   * ```
+   */
+  attributes?: AttributesProp;
 }
 
 /**
@@ -92,6 +111,7 @@ export function InterfaceProperty(props: InterfacePropertyProps) {
     <MemberDeclaration symbol={propertySymbol}>
       <Scope value={propertyScope}>
         <DocWhen doc={props.doc} />
+        <AttributeList attributes={props.attributes} endline />
         {modifiers}
         {props.type}
         {props.nullable && "?"} {name}{" "}

package/src/components/property/property.test.tsx

@@ -1,6 +1,7 @@
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
+import { Attribute } from "../attributes/attributes.jsx";
 import { ClassDeclaration } from "../ClassDeclaration.jsx";
 import { Property } from "./property.jsx";
 
@@ -186,3 +187,23 @@ it("specify initializer", () => {
     }
   `);
 });
+
+it("specify attributes", () => {
+  expect(
+    <Wrapper>
+      <Property
+        name="Test"
+        type="int"
+        attributes={[<Attribute name="Test" />]}
+        get
+        set
+      />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+      [Test]
+      int Test { get; set; }
+    }
+  `);
+});

package/src/components/property/property.tsx

@@ -17,6 +17,7 @@ import {
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
 import { CSharpMemberScope, useCSharpScope } from "../../symbols/scopes.js";
+import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 
 /** Property modifiers. */
@@ -87,6 +88,24 @@ export interface PropertyProps extends AccessModifiers, PropertyModifiers {
    * ```
    */
   initializer?: Children;
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <Property name="MyProp" attributes={[
+   *  <Attribute name="Test" />
+   *  <Attribute name="Test2" args={["arg1", "arg2"]} />
+   * ]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test]
+   * [Test2("arg1", "arg2")]
+   * int MyProp { get; set; }
+   * ```
+   */
+  attributes?: AttributesProp;
 }
 
 /**
@@ -135,6 +154,7 @@ export function Property(props: PropertyProps) {
     <MemberDeclaration symbol={propertySymbol}>
       <Scope value={propertyScope}>
         <DocWhen doc={props.doc} />
+        <AttributeList attributes={props.attributes} endline />
         {modifiers}
         {props.type}
         {props.nullable && "?"} {name}{" "}