@alloy-js/csharp 0.23.0-dev.8 → 0.24.0-dev.0

package/docs/api/components/Property.md

@@ -16,7 +16,7 @@ Properties for [Property](../property/) component
     doc={Children}
     extern
     file
-    get
+    get={boolean | Children}
     init
     initializer={Children}
     internal
@@ -31,7 +31,7 @@ Properties for [Property](../property/) component
     refkey={Refkey}
     required
     sealed
-    set
+    set={boolean | Children}
     static
     type={Children}
     virtual
@@ -50,7 +50,7 @@ Properties for [Property](../property/) component
     doc: Children,
     extern: boolean,
     file: boolean,
-    get: boolean,
+    get: boolean | Children,
     init: boolean,
     initializer: Children,
     internal: boolean,
@@ -65,7 +65,7 @@ Properties for [Property](../property/) component
     refkey: Refkey,
     required: boolean,
     sealed: boolean,
-    set: boolean,
+    set: boolean | Children,
     static: boolean,
     type: Children,
     virtual: boolean,
@@ -74,32 +74,32 @@ Properties for [Property](../property/) component
 
 ## Props
 
-|             |                                                        |                                                                                                                          |
-| ----------- | ------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ |
-| abstract    | optional boolean                                       |                                                                                                                          |
-| attributes  | optional [AttributesProp](../../types/attributesprop/) | Define attributes to attach                                                                                              |
-| doc         | optional [Children](../../../core/types/children/)     | Doc comment                                                                                                              |
-| extern      | optional boolean                                       |                                                                                                                          |
-| file        | optional boolean                                       |                                                                                                                          |
-| get         | optional boolean                                       | If property should have a getter                                                                                         |
-| init        | optional boolean                                       | If property should only be set on the type creation                                                                      |
-| initializer | optional [Children](../../../core/types/children/)     | Property initializer                                                                                                     |
-| internal    | optional boolean                                       |                                                                                                                          |
-| name        | [Namekey](../../../core/types/namekey/) \| string      |                                                                                                                          |
-| new         | optional boolean                                       |                                                                                                                          |
-| nullable    | optional boolean                                       | Property initializer                                                                                                     |
-| override    | optional boolean                                       |                                                                                                                          |
-| private     | optional boolean                                       |                                                                                                                          |
-| protected   | optional boolean                                       |                                                                                                                          |
-| public      | optional boolean                                       |                                                                                                                          |
-| readonly    | optional boolean                                       |                                                                                                                          |
-| refkey      | optional [Refkey](../../../core/types/refkey/)         |                                                                                                                          |
-| required    | optional boolean                                       | Set required modifier on property <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required> |
-| sealed      | optional boolean                                       |                                                                                                                          |
-| set         | optional boolean                                       | If property should have a setter                                                                                         |
-| static      | optional boolean                                       |                                                                                                                          |
-| type        | [Children](../../../core/types/children/)              | Property type                                                                                                            |
-| virtual     | optional boolean                                       |                                                                                                                          |
+|             |                                                               |                                                                                                                                |
+| ----------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| abstract    | optional boolean                                              |                                                                                                                                |
+| attributes  | optional [AttributesProp](../../types/attributesprop/)        | Define attributes to attach                                                                                                    |
+| doc         | optional [Children](../../../core/types/children/)            | Doc comment                                                                                                                    |
+| extern      | optional boolean                                              |                                                                                                                                |
+| file        | optional boolean                                              |                                                                                                                                |
+| get         | optional boolean \| [Children](../../../core/types/children/) | If property should have a getter. Pass `true` for an auto-property getter (`get;`), or pass children for a getter with a body. |
+| init        | optional boolean                                              | If property should only be set on the type creation                                                                            |
+| initializer | optional [Children](../../../core/types/children/)            | Property initializer                                                                                                           |
+| internal    | optional boolean                                              |                                                                                                                                |
+| name        | [Namekey](../../../core/types/namekey/) \| string             |                                                                                                                                |
+| new         | optional boolean                                              |                                                                                                                                |
+| nullable    | optional boolean                                              | Property initializer                                                                                                           |
+| override    | optional boolean                                              |                                                                                                                                |
+| private     | optional boolean                                              |                                                                                                                                |
+| protected   | optional boolean                                              |                                                                                                                                |
+| public      | optional boolean                                              |                                                                                                                                |
+| readonly    | optional boolean                                              |                                                                                                                                |
+| refkey      | optional [Refkey](../../../core/types/refkey/)                |                                                                                                                                |
+| required    | optional boolean                                              | Set required modifier on property <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required>       |
+| sealed      | optional boolean                                              |                                                                                                                                |
+| set         | optional boolean \| [Children](../../../core/types/children/) | If property should have a setter. Pass `true` for an auto-property setter (`set;`), or pass children for a setter with a body. |
+| static      | optional boolean                                              |                                                                                                                                |
+| type        | [Children](../../../core/types/children/)                     | Property type                                                                                                                  |
+| virtual     | optional boolean                                              |                                                                                                                                |
 
 ## Example
 

package/docs/api/contexts/csharp-context.md

@@ -0,0 +1,21 @@
+# csharp context
+
+C# contextual keywords that are reserved in certain contexts. While not always reserved, treating them as keywords in generated code avoids subtle context-dependent issues.
+
+```ts
+const csharpContextualKeywords: ReadonlySet<string>
+```
+
+## Accessor
+
+```ts
+const myContext = useContext(csharpContext);
+```
+
+## Context interface
+
+string
+
+## See also
+
+* <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/#contextual-keywords>

package/docs/api/contexts/index.md

@@ -0,0 +1,3 @@
+# csharp — contexts
+
+- [csharp context](csharp-context.md) — C# contextual keywords that are reserved in certain contexts.

package/docs/api/functions/createCSharpNamePolicy.md

@@ -1,5 +1,9 @@
 # createCSharpNamePolicy
 
+Creates the C# naming policy with case conversion and keyword escaping.
+
+After applying the appropriate case conversion for each element kind, the resulting name is checked against C# reserved and contextual keywords. If it matches (case-sensitively), the name is prefixed with `@`.
+
 ```ts
 import { createCSharpNamePolicy } from "@alloy-js/csharp";
 

package/docs/api/functions/index.md

@@ -4,7 +4,7 @@
 - [accessibilityFromProps](accessibilityFromProps.md) — import { accessibilityFromProps } from "@alloy-js/csharp";
 - [computeModifiersPrefix](computeModifiersPrefix.md) — Resolve the modifier prefix
 - [createClassScope](createClassScope.md) — import { createClassScope } from "@alloy-js/csharp";
-- [createCSharpNamePolicy](createCSharpNamePolicy.md) — import { createCSharpNamePolicy } from "@alloy-js/csharp";
+- [createCSharpNamePolicy](createCSharpNamePolicy.md) — Creates the C# naming policy with case conversion and keyword escaping.
 - [createCSharpNamespaceScope](createCSharpNamespaceScope.md) — import { createCSharpNamespaceScope } from "@alloy-js/csharp";
 - [createFieldSymbol](createFieldSymbol.md) — import { createFieldSymbol } from "@alloy-js/csharp";
 - [createLibrary](createLibrary.md) — import { createLibrary } from "@alloy-js/csharp";
@@ -19,9 +19,13 @@
 - [createVariableSymbol](createVariableSymbol.md) — import { createVariableSymbol } from "@alloy-js/csharp";
 - [getAccessModifier](getAccessModifier.md) — import { getAccessModifier } from "@alloy-js/csharp";
 - [getAsyncModifier](getAsyncModifier.md) — import { getAsyncModifier } from "@alloy-js/csharp";
+- [isCSharpContextualKeyword](isCSharpContextualKeyword.md) — Returns true if the given name is a C# contextual keyword.
+- [isCSharpKeyword](isCSharpKeyword.md) — Returns true if the given name is a C# reserved keyword.
+- [isValidCSharpIdentifier](isValidCSharpIdentifier.md) — Checks whether the provided name is a valid C# identifier (without `@` prefix).
 - [makeModifiers](makeModifiers.md) — import { makeModifiers } from "@alloy-js/csharp";
 - [nonAccessibilityFromProps](nonAccessibilityFromProps.md) — import { nonAccessibilityFromProps } from "@alloy-js/csharp";
 - [ref](ref.md) — import { ref } from "@alloy-js/csharp";
+- [sanitizeCSharpIdentifier](sanitizeCSharpIdentifier.md) — Transforms an arbitrary string into a valid C# identifier by replacing invalid characters.
 - [useCsharpFormatOptions](useCsharpFormatOptions.md) — import { useCsharpFormatOptions } from "@alloy-js/csharp";
 - [useCSharpNamePolicy](useCSharpNamePolicy.md) — import { useCSharpNamePolicy } from "@alloy-js/csharp";
 - [useCSharpScope](useCSharpScope.md) — import { useCSharpScope } from "@alloy-js/csharp";

package/docs/api/functions/isCSharpContextualKeyword.md

@@ -0,0 +1,20 @@
+# isCSharpContextualKeyword
+
+Returns true if the given name is a C# contextual keyword. Contextual keywords are only reserved in specific language contexts and are generally valid as identifiers.
+
+```ts
+import { isCSharpContextualKeyword } from "@alloy-js/csharp";
+
+
+function isCSharpContextualKeyword(name: string): boolean;
+```
+
+## Parameters
+
+|      |        |   |
+| ---- | ------ | - |
+| name | string |   |
+
+## Returns
+
+boolean

package/docs/api/functions/isCSharpKeyword.md

@@ -0,0 +1,22 @@
+# isCSharpKeyword
+
+Returns true if the given name is a C# reserved keyword. The check is case-sensitive, matching C# language semantics.
+
+Note: this only checks reserved keywords, not contextual keywords. Contextual keywords are only reserved in specific language contexts and are valid identifiers elsewhere (e.g., `value` is valid as a parameter name). Use [isCSharpContextualKeyword](../iscsharpcontextualkeyword/) to check contextual keywords separately.
+
+```ts
+import { isCSharpKeyword } from "@alloy-js/csharp";
+
+
+function isCSharpKeyword(name: string): boolean;
+```
+
+## Parameters
+
+|      |        |   |
+| ---- | ------ | - |
+| name | string |   |
+
+## Returns
+
+boolean

package/docs/api/functions/isValidCSharpIdentifier.md

@@ -0,0 +1,20 @@
+# isValidCSharpIdentifier
+
+Checks whether the provided name is a valid C# identifier (without `@` prefix). Does not account for keyword conflicts — use [isCSharpKeyword](../iscsharpkeyword/) for that.
+
+```ts
+import { isValidCSharpIdentifier } from "@alloy-js/csharp";
+
+
+function isValidCSharpIdentifier(name: string): boolean;
+```
+
+## Parameters
+
+|      |        |   |
+| ---- | ------ | - |
+| name | string |   |
+
+## Returns
+
+boolean true if the name matches C# identifier rules (letter or underscore start, word chars after).

package/docs/api/functions/sanitizeCSharpIdentifier.md

@@ -0,0 +1,24 @@
+# sanitizeCSharpIdentifier
+
+Transforms an arbitrary string into a valid C# identifier by replacing invalid characters. The result may still be a C# keyword — callers should combine with keyword escaping if needed.
+
+* If the first character is not a letter or underscore, a `_` prefix is added.
+* Subsequent non-word characters are replaced with `_`.
+* Empty strings become `_`.
+
+```ts
+import { sanitizeCSharpIdentifier } from "@alloy-js/csharp";
+
+
+function sanitizeCSharpIdentifier(name: string): string;
+```
+
+## Parameters
+
+|      |        |   |
+| ---- | ------ | - |
+| name | string |   |
+
+## Returns
+
+string A string that satisfies C# identifier character rules.

package/docs/api/index.md

@@ -1,6 +1,7 @@
 # @alloy-js/csharp API Reference
 
 - [components](components/index.md) (53 items)
-- [functions](functions/index.md) (31 items)
+- [contexts](contexts/index.md) (1 items)
+- [functions](functions/index.md) (35 items)
 - [types](types/index.md) (60 items)
-- [variables](variables/index.md) (1 items)
+- [variables](variables/index.md) (2 items)

package/docs/api/variables/csharpKeywords.md

@@ -0,0 +1,11 @@
+# csharpKeywords
+
+C# reserved keywords that cannot be used as identifiers without `@` prefix. These are case-sensitive in C#.
+
+```ts
+csharpKeywords: ReadonlySet<string>
+```
+
+## See also
+
+* <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/>

package/docs/api/variables/index.md

@@ -1,3 +1,4 @@
 # csharp — variables
 
 - [Attribute](Attribute.md) — Render a csharp attribute.
+- [csharpKeywords](csharpKeywords.md) — C# reserved keywords that cannot be used as identifiers without `@` prefix.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-js/csharp",
-  "version": "0.23.0-dev.8",
+  "version": "0.24.0-dev.0",
   "description": "Alloy components for CSharp language.",
   "repository": {
     "type": "git",
@@ -43,16 +43,16 @@
   "author": "jhendrix@microsoft.com",
   "license": "MIT",
   "dependencies": {
-    "@alloy-js/core": "~0.22.0 || >= 0.23.0-dev.16",
-    "@alloy-js/msbuild": "~0.22.0 || >= 0.23.0-dev.2",
+    "@alloy-js/core": "~0.23.0 || >= 0.24.0-dev.1",
+    "@alloy-js/msbuild": "~0.23.0 || >= 0.24.0-dev.0",
     "change-case": "^5.4.4",
     "marked": "^16.1.1",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@alloy-js/cli": "~0.22.0 || >= 0.23.0-dev.6",
-    "@alloy-js/rollup-plugin": "~0.1.0 || >= 0.1.1-dev.2",
-    "@alloy-js/typescript": "~0.22.0 || >= 0.23.0-dev.9",
+    "@alloy-js/cli": "~0.23.0 || >= 0.24.0-dev.0",
+    "@alloy-js/rollup-plugin": "~0.1.1 || >= 0.1.2-dev.1",
+    "@alloy-js/typescript": "~0.23.0 || >= 0.24.0-dev.0",
     "@microsoft/api-extractor": "~7.52.8",
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/js-yaml": "^4.0.9",

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

@@ -207,3 +207,39 @@ describe("format", () => {
   `);
   });
 });
+
+describe("name policy deduplication", () => {
+  it("deduplicates parameters that collide after case conversion", () => {
+    const params = [
+      { name: "my-param", type: "int" },
+      { name: "myParam", type: "string" },
+    ];
+    expect(
+      <Wrapper>
+        <Method public name="MethodOne" parameters={params} />
+      </Wrapper>,
+    ).toRenderTo(`
+      public class TestClass
+      {
+          public void MethodOne(int myParam, string myParam_2) {}
+      }
+    `);
+  });
+
+  it("deduplicates parameters that are keywords", () => {
+    const params = [
+      { name: "string", type: "int" },
+      { name: "string", type: "bool" },
+    ];
+    expect(
+      <Wrapper>
+        <Method public name="MethodOne" parameters={params} />
+      </Wrapper>,
+    ).toRenderTo(`
+      public class TestClass
+      {
+          public void MethodOne(int @string, bool string_2) {}
+      }
+    `);
+  });
+});

package/src/components/namespace/namespace.test.tsx

@@ -138,8 +138,10 @@ it("define nested namespace in sourcefile", () => {
   );
 
   expect(tree).toRenderTo(`
-    namespace Base {
-        namespace Namespace1.Namespace2 {
+    namespace Base
+    {
+        namespace Namespace1.Namespace2
+        {
             public class Model1;
         }
     }
@@ -170,7 +172,8 @@ it("contains a struct with a private field initialized by a constructor", () =>
   );
 
   expect(tree).toRenderTo(d`
-    namespace TestNamespace.Test {
+    namespace TestNamespace.Test
+    {
         public struct MyStruct
         {
             private int _value;

package/src/components/namespace/namespace.tsx

@@ -38,8 +38,8 @@ export function Namespace(props: NamespaceProps) {
         <NamespaceName
           symbol={namespaceSymbol}
           relative={!!hasOuterNamespace}
-        />{" "}
-        <Block>
+        />
+        <Block newline>
           <NamespaceScopes symbol={namespaceSymbol} stopAt={nsContext?.symbol}>
             {props.children}
           </NamespaceScopes>

package/src/components/namespace.ref.test.tsx

@@ -43,9 +43,11 @@ it("references types in a parent namespace", () => {
   );
 
   expect(tree).toRenderTo(`
-    namespace Test {
+    namespace Test
+    {
         class TestClass;
-        namespace Nested {
+        namespace Nested
+        {
             TestClass;
         }
     }
@@ -69,9 +71,11 @@ it("references types in a child namespace", () => {
   );
 
   expect(tree).toRenderTo(`
-    namespace Test {
+    namespace Test
+    {
         Nested.TestClass;
-        namespace Nested {
+        namespace Nested
+        {
             class TestClass;
         }
     }
@@ -96,10 +100,12 @@ it("references types in a different top-level namespace declared in the same fil
   expect(tree).toRenderTo(`
     using TestCode2;
 
-    namespace TestCode1 {
+    namespace TestCode1
+    {
         TestClass
     }
-    namespace TestCode2 {
+    namespace TestCode2
+    {
         class TestClass;
     }
   `);
@@ -125,12 +131,14 @@ it("references types in a different top-level namespace declared in a different
     "test.cs": `
       using TestCode2;
 
-      namespace TestCode1 {
+      namespace TestCode1
+      {
           TestClass;
       }
     `,
     "other.cs": `
-        namespace TestCode2 {
+        namespace TestCode2
+        {
             class TestClass;
         }
       `,
@@ -156,7 +164,8 @@ it("can be referenced by refkey", () => {
   expect(tree).toRenderTo(`
     using TestCode2;
 
-    namespace TestCode2 {
+    namespace TestCode2
+    {
         class TestClass;
     }
     TestClass;
@@ -181,11 +190,14 @@ it("references types across sibling namespaces under the same parent", () => {
   );
 
   expect(tree).toRenderTo(`
-    namespace Parent {
-        namespace Models {
+    namespace Parent
+    {
+        namespace Models
+        {
             class User;
         }
-        namespace Services {
+        namespace Services
+        {
             Models.User;
         }
     }

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

@@ -232,3 +232,92 @@ describe("format", () => {
   `);
   });
 });
+
+describe("accessor bodies", () => {
+  it("renders get with body", () => {
+    expect(
+      <Wrapper>
+        <Property public name="Name" type="string" get={<>return _name;</>} />
+      </Wrapper>,
+    ).toRenderTo(`
+      public class TestClass
+      {
+          public string Name
+          {
+              get { return _name; }
+          }
+      }
+    `);
+  });
+
+  it("renders set with body", () => {
+    expect(
+      <Wrapper>
+        <Property
+          public
+          name="Value"
+          type="int"
+          get
+          set={<>_value = value;</>}
+        />
+      </Wrapper>,
+    ).toRenderTo(`
+      public class TestClass
+      {
+          public int Value
+          {
+              get;
+              set { _value = value; }
+          }
+      }
+    `);
+  });
+
+  it("renders both get and set with bodies", () => {
+    expect(
+      <Wrapper>
+        <Property
+          public
+          name="MinValue"
+          type="T"
+          get={<>return _minValue.HasValue ? _minValue.Value : default(T);</>}
+          set={<>_minValue = value;</>}
+        />
+      </Wrapper>,
+    ).toRenderTo(`
+      public class TestClass
+      {
+          public T MinValue
+          {
+              get { return _minValue.HasValue ? _minValue.Value : default(T); }
+              set { _minValue = value; }
+          }
+      }
+    `);
+  });
+
+  it("breaks long accessor body across lines", () => {
+    expect(
+      <TestNamespace printWidth={40}>
+        <ClassDeclaration name="Test">
+          <Property
+            public
+            name="Value"
+            type="int"
+            get={<>return _someVeryLongFieldName;</>}
+          />
+        </ClassDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      class Test
+      {
+          public int Value
+          {
+              get {
+                  return _someVeryLongFieldName;
+              }
+          }
+      }
+  `);
+  });
+});