@alloy-js/csharp 0.23.0-dev.1 → 0.23.0-dev.11

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,9 +164,42 @@ it("can be referenced by refkey", () => {
   expect(tree).toRenderTo(`
     using TestCode2;
 
-    namespace TestCode2 {
+    namespace TestCode2
+    {
         class TestClass;
     }
     TestClass;
   `);
 });
+
+it("references types across sibling namespaces under the same parent", () => {
+  const classRef = refkey();
+
+  const tree = (
+    <Output>
+      <SourceFile path="test.cs">
+        <Namespace name="Parent">
+          <Namespace name="Models">
+            <ClassDeclaration name="User" refkey={classRef} />
+          </Namespace>
+          <hbr />
+          <Namespace name="Services">{classRef};</Namespace>
+        </Namespace>
+      </SourceFile>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    namespace Parent
+    {
+        namespace Models
+        {
+            class User;
+        }
+        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

@@ -8,6 +8,7 @@ import {
   Children,
   computed,
   SourceFile as CoreSourceFile,
+  createScope,
   List,
   Scope,
   Show,
@@ -45,10 +46,18 @@ export interface SourceFileProps extends CSharpFormatOptions {
 
 /** A C# source file exists within the context of a namespace contains using statements and declarations */
 export function SourceFile(props: SourceFileProps) {
-  const sourceFileScope = new CSharpSourceFileScope(props.path);
+  const binder = useBinder();
+  const sourceFileScope = createScope(
+    CSharpSourceFileScope,
+    props.path,
+    undefined,
+    {
+      binder,
+    },
+  );
 
   const nsContext = useNamespaceContext();
-  const globalNs = getGlobalNamespace(useBinder());
+  const globalNs = getGlobalNamespace(binder);
   const nsSymbol = nsContext ? nsContext.symbol : globalNs;
   const usings = computed(() => {
     return (
@@ -96,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/contexts/global-namespace.ts

@@ -1,4 +1,4 @@
-import { Binder, useBinder } from "@alloy-js/core";
+import { Binder, createSymbol, useBinder } from "@alloy-js/core";
 import { NamespaceSymbol } from "../symbols/namespace.js";
 
 export function useGlobalNamespace() {
@@ -7,12 +7,17 @@ export function useGlobalNamespace() {
 }
 
 const globalNamespaces = new WeakMap<Binder, NamespaceSymbol>();
-let defaultGlobalNamespace = new NamespaceSymbol("global", undefined, {
-  isGlobal: true,
-});
+let defaultGlobalNamespace = createSymbol(
+  NamespaceSymbol,
+  "global",
+  undefined,
+  {
+    isGlobal: true,
+  },
+);
 
 export function resetGlobalNamespace() {
-  defaultGlobalNamespace = new NamespaceSymbol("global", undefined, {
+  defaultGlobalNamespace = createSymbol(NamespaceSymbol, "global", undefined, {
     isGlobal: true,
   });
 }
@@ -25,7 +30,7 @@ export function getGlobalNamespace(binder: Binder | undefined) {
   let namespace = globalNamespaces.get(binder);
 
   if (!namespace) {
-    namespace = new NamespaceSymbol("global", undefined, {
+    namespace = createSymbol(NamespaceSymbol, "global", undefined, {
       binder,
       isGlobal: true,
     });

package/src/create-library.ts

@@ -1,5 +1,6 @@
 import {
   Binder,
+  createSymbol,
   LibrarySymbolReference,
   namekey,
   refkey,
@@ -124,10 +125,15 @@ export function createLibrary<T extends Record<string, Descriptor>>(
                 name,
               )! as NamespaceSymbol;
             } else {
-              ownerSymbol = new NamespaceSymbol(namekey(name), ownerSymbol!, {
-                binder,
-                refkeys: refkey(),
-              });
+              ownerSymbol = createSymbol(
+                NamespaceSymbol,
+                namekey(name),
+                ownerSymbol!,
+                {
+                  binder,
+                  refkeys: refkey(),
+                },
+              );
             }
           }
 
@@ -214,7 +220,8 @@ function createSymbolFromDescriptor(
       if (ownerSymbol.members.symbolNames.has(name)) {
         return ownerSymbol.members.symbolNames.get(name)! as NamespaceSymbol;
       }
-      return new NamespaceSymbol(
+      return createSymbol(
+        NamespaceSymbol,
         namekey(name),
         ownerSymbol as NamespaceSymbol,
         {
@@ -228,7 +235,8 @@ function createSymbolFromDescriptor(
     case "interface":
     case "struct":
     case "record":
-      return new NamedTypeSymbol(
+      return createSymbol(
+        NamedTypeSymbol,
         namekey(name),
         ownerSymbol.members,
         descriptor.kind,
@@ -239,7 +247,8 @@ function createSymbolFromDescriptor(
         },
       );
     case "method":
-      return new MethodSymbol(
+      return createSymbol(
+        MethodSymbol,
         namekey(name),
         ownerSymbol.members,
         descriptor.methodKind,
@@ -250,7 +259,7 @@ function createSymbolFromDescriptor(
       );
     case "field":
     case "property":
-      return new CSharpSymbol(namekey(name), ownerSymbol.members, {
+      return createSymbol(CSharpSymbol, namekey(name), ownerSymbol.members, {
         binder,
         refkeys: refkey(),
         type:
@@ -262,7 +271,7 @@ function createSymbolFromDescriptor(
         lazyMemberInitializer,
       });
     case "generic":
-      return new CSharpSymbol(namekey(name), ownerSymbol.members, {
+      return createSymbol(CSharpSymbol, namekey(name), ownerSymbol.members, {
         binder,
         refkeys: refkey(),
       });

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