@alloy-js/csharp 0.23.0-dev.7 → 0.23.0

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;
+              }
+          }
+      }
+  `);
+  });
+});

package/src/components/property/property.tsx

@@ -1,4 +1,5 @@
 import {
+  Block,
   Children,
   createSymbolSlot,
   List,
@@ -54,11 +55,49 @@ export interface PropertyProps extends AccessModifiers, PropertyModifiers {
   /** Property type */
   type: Children;
 
-  /** If property should have a getter */
-  get?: boolean;
+  /**
+   * If property should have a getter. Pass `true` for an auto-property getter (`get;`),
+   * or pass children for a getter with a body.
+   *
+   * @example auto-property
+   * ```tsx
+   * <Property name="Name" type="string" get set />
+   * ```
+   * Produces: `string Name { get; set; }`
+   *
+   * @example with body
+   * ```tsx
+   * <Property name="Name" type="string" get={<>return _name;</>} set />
+   * ```
+   * Produces:
+   * ```csharp
+   * string Name
+   * {
+   *     get { return _name; }
+   *     set;
+   * }
+   * ```
+   */
+  get?: boolean | Children;
 
-  /** If property should have a setter */
-  set?: boolean;
+  /**
+   * If property should have a setter. Pass `true` for an auto-property setter (`set;`),
+   * or pass children for a setter with a body.
+   *
+   * @example with body
+   * ```tsx
+   * <Property name="Value" type="int" get set={<>_value = value;</>} />
+   * ```
+   * Produces:
+   * ```csharp
+   * int Value
+   * {
+   *     get;
+   *     set { _value = value; }
+   * }
+   * ```
+   */
+  set?: boolean | Children;
 
   /** If property should only be set on the type creation */
   init?: boolean;
@@ -133,14 +172,42 @@ export function Property(props: PropertyProps) {
       `Cannot use 'init' and 'set' together on property '${name}'`,
     );
   }
-  // note that scope wraps the method decl so that the params get the correct scope
+
+  const hasAccessorBody =
+    (props.get && props.get !== true) || (props.set && props.set !== true);
+
   return (
     <MemberDeclaration symbol={propertySymbol}>
       <DocWhen doc={props.doc} />
       <AttributeList attributes={props.attributes} endline />
       {modifiers}
       <TypeSlot>{props.type}</TypeSlot>
-      {props.nullable && "?"} <MemberName /> {"{ "}
+      {props.nullable && "?"} <MemberName />
+      {hasAccessorBody ?
+        <AccessorBlock get={props.get} set={props.set} init={props.init} />
+      : <AutoAccessors
+          get={props.get}
+          set={props.set}
+          init={props.init}
+          initializer={props.initializer}
+        />
+      }
+    </MemberDeclaration>
+  );
+}
+
+interface AutoAccessorsProps {
+  get?: boolean | Children;
+  set?: boolean | Children;
+  init?: boolean;
+  initializer?: Children;
+}
+
+function AutoAccessors(props: AutoAccessorsProps) {
+  return (
+    <group>
+      {" "}
+      {"{ "}
       <List joiner=" ">
         {props.get && "get;"}
         {props.set && "set;"}
@@ -148,20 +215,48 @@ export function Property(props: PropertyProps) {
       </List>
       {" }"}
       {props.initializer && (
-        <PropertyInitializer>{props.initializer}</PropertyInitializer>
+        <>
+          {" ="}
+          <indent>
+            <line />
+            {props.initializer};
+          </indent>
+        </>
       )}
-    </MemberDeclaration>
+    </group>
+  );
+}
+
+interface AccessorBlockProps {
+  get?: boolean | Children;
+  set?: boolean | Children;
+  init?: boolean;
+}
+
+function AccessorBlock(props: AccessorBlockProps) {
+  return (
+    <Block newline>
+      <List hardline>
+        {props.get && <Accessor keyword="get" body={props.get} />}
+        {props.set && <Accessor keyword="set" body={props.set} />}
+        {props.init && "init;"}
+      </List>
+    </Block>
   );
 }
 
-function PropertyInitializer(props: { children: Children }) {
+interface AccessorProps {
+  keyword: string;
+  body: boolean | Children;
+}
+
+function Accessor(props: AccessorProps) {
+  if (props.body === true) {
+    return <>{props.keyword};</>;
+  }
   return (
-    <group>
-      {" ="}
-      <indent>
-        <line />
-        {props.children};
-      </indent>
-    </group>
+    <>
+      {props.keyword} <Block inline>{props.body}</Block>
+    </>
   );
 }

package/src/components/source-file/source-file.tsx

@@ -105,10 +105,7 @@ export function SourceFile(props: SourceFileProps) {
         : <>
             namespace <NamespaceName symbol={nsSymbol} />
             {sourceFileScope.hasBlockNamespace ?
-              <>
-                {" "}
-                <Block>{content}</Block>
-              </>
+              <Block newline>{content}</Block>
             : <>
                 ;<hbr />
                 <hbr />

package/src/identifier-utils.ts

@@ -0,0 +1,45 @@
+/**
+ * Checks whether the provided name is a valid C# identifier (without `@` prefix).
+ * Does not account for keyword conflicts — use {@link isCSharpKeyword} for that.
+ *
+ * @param name - The name to validate.
+ * @returns true if the name matches C# identifier rules (letter or underscore start, word chars after).
+ */
+export function isValidCSharpIdentifier(name: string): boolean {
+  return /^[A-Za-z_]\w*$/.test(name);
+}
+
+/**
+ * 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 `_`.
+ *
+ * @param name - The string to sanitize.
+ * @returns A string that satisfies C# identifier character rules.
+ */
+export function sanitizeCSharpIdentifier(name: string): string {
+  if (name.length === 0) return "_";
+
+  const chars: string[] = [];
+  for (let i = 0; i < name.length; i++) {
+    const ch = name[i];
+    if (i === 0) {
+      if (/[A-Za-z_]/.test(ch)) {
+        chars.push(ch);
+      } else {
+        chars.push("_");
+        // Keep the original char if it's a word char (e.g., digit)
+        if (/\w/.test(ch)) {
+          chars.push(ch);
+        }
+      }
+    } else {
+      chars.push(/\w/.test(ch) ? ch : "_");
+    }
+  }
+  return chars.join("");
+}

package/src/index.ts

@@ -2,6 +2,8 @@ export * from "./access.jsx";
 export * from "./components/index.js";
 export * from "./contexts/format-options.js";
 export * from "./create-library.js";
+export * from "./identifier-utils.js";
+export * from "./keywords.js";
 export * from "./modifiers.js";
 export * from "./name-policy.js";
 export * from "./scopes/index.js";

package/src/keywords.ts

@@ -0,0 +1,162 @@
+/**
+ * C# reserved keywords that cannot be used as identifiers without `@` prefix.
+ * These are case-sensitive in C#.
+ *
+ * @see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/
+ */
+export const csharpKeywords: ReadonlySet<string> = new Set([
+  "abstract",
+  "as",
+  "base",
+  "bool",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "checked",
+  "class",
+  "const",
+  "continue",
+  "decimal",
+  "default",
+  "delegate",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "event",
+  "explicit",
+  "extern",
+  "false",
+  "finally",
+  "fixed",
+  "float",
+  "for",
+  "foreach",
+  "goto",
+  "if",
+  "implicit",
+  "in",
+  "int",
+  "interface",
+  "internal",
+  "is",
+  "lock",
+  "long",
+  "namespace",
+  "new",
+  "null",
+  "object",
+  "operator",
+  "out",
+  "override",
+  "params",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "ref",
+  "return",
+  "sbyte",
+  "sealed",
+  "short",
+  "sizeof",
+  "stackalloc",
+  "static",
+  "string",
+  "struct",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "uint",
+  "ulong",
+  "unchecked",
+  "unsafe",
+  "ushort",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "while",
+]);
+
+/**
+ * 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.
+ *
+ * @see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/#contextual-keywords
+ */
+export const csharpContextualKeywords: ReadonlySet<string> = new Set([
+  "add",
+  "allows",
+  "alias",
+  "and",
+  "ascending",
+  "args",
+  "async",
+  "await",
+  "by",
+  "descending",
+  "dynamic",
+  "equals",
+  "field",
+  "file",
+  "from",
+  "get",
+  "global",
+  "group",
+  "init",
+  "into",
+  "join",
+  "let",
+  "managed",
+  "nameof",
+  "nint",
+  "not",
+  "notnull",
+  "nuint",
+  "on",
+  "or",
+  "orderby",
+  "partial",
+  "record",
+  "remove",
+  "required",
+  "scoped",
+  "select",
+  "set",
+  "unmanaged",
+  "value",
+  "var",
+  "when",
+  "where",
+  "with",
+  "yield",
+]);
+
+/**
+ * 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 {@link isCSharpContextualKeyword} to check contextual keywords separately.
+ */
+export function isCSharpKeyword(name: string): boolean {
+  return csharpKeywords.has(name);
+}
+
+/**
+ * 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.
+ */
+export function isCSharpContextualKeyword(name: string): boolean {
+  return csharpContextualKeywords.has(name);
+}