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

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/scopes/csharp.ts

@@ -20,4 +20,15 @@ export class CSharpScope extends OutputScope {
   get ownerSymbol(): CSharpSymbol | undefined {
     return super.ownerSymbol as CSharpSymbol | undefined;
   }
+
+  override get debugInfo(): Record<string, unknown> {
+    const info = super.debugInfo;
+    if (this.enclosingNamespace) {
+      return {
+        ...info,
+        enclosingNamespace: this.enclosingNamespace.name,
+      };
+    }
+    return info;
+  }
 }

package/src/scopes/factories.ts

@@ -1,4 +1,4 @@
-import { OutputScopeOptions } from "@alloy-js/core";
+import { OutputScopeOptions, createScope } from "@alloy-js/core";
 import { NamedTypeSymbol } from "../symbols/named-type.js";
 import { CSharpClassScope } from "./class.js";
 import { useCSharpScope, useNamedTypeScope } from "./contexts.js";
@@ -21,7 +21,7 @@ export function createNamedTypeScope(
     );
   }
 
-  return new CSharpNamedTypeScope(ownerSymbol, currentScope, options);
+  return createScope(CSharpNamedTypeScope, ownerSymbol, currentScope, options);
 }
 
 export function createClassScope(
@@ -37,9 +37,9 @@ export function createClassScope(
       "Can't create C# class scope inside of " + currentScope.constructor.name,
     );
   }
-  return new CSharpClassScope(ownerSymbol, currentScope, options);
+  return createScope(CSharpClassScope, ownerSymbol, currentScope, options);
 }
 export function createMethodScope(options: OutputScopeOptions = {}) {
   const parentScope = useNamedTypeScope();
-  return new CSharpMethodScope("method scope", parentScope, options);
+  return createScope(CSharpMethodScope, "method scope", parentScope, options);
 }

package/src/scopes/namespace.ts

@@ -1,4 +1,4 @@
-import { OutputScope, useScope } from "@alloy-js/core";
+import { OutputScope, createScope, useScope } from "@alloy-js/core";
 import type { NamespaceSymbol } from "../symbols/namespace.js";
 import { CSharpNamedTypeScope } from "./named-type.js";
 import { CSharpSourceFileScope } from "./source-file.js";
@@ -32,7 +32,7 @@ export function createCSharpNamespaceScope(namespaceSymbol: NamespaceSymbol) {
     );
   }
 
-  const scope = new CSharpNamespaceScope(namespaceSymbol, parentScope);
+  const scope = createScope(CSharpNamespaceScope, namespaceSymbol, parentScope);
 
   return scope;
 }

package/src/symbols/csharp.ts

@@ -1,4 +1,5 @@
 import {
+  createSymbol,
   Namekey,
   OutputDeclarationSpace,
   OutputMemberSpace,
@@ -128,8 +129,10 @@ export class CSharpSymbol extends OutputSymbol {
 
   copy() {
     const options = this.getCopyOptions();
-    const copy = new CSharpSymbol(this.name, undefined, {
+    const binder = this.binder;
+    const copy = createSymbol(CSharpSymbol, this.name, undefined, {
       ...options,
+      binder,
       accessibility: this.#accessibility,
       isStatic: this.#isStatic,
       isVirtual: this.#isVirtual,
@@ -151,6 +154,22 @@ export class CSharpSymbol extends OutputSymbol {
     return copy;
   }
 
+  override get debugInfo(): Record<string, unknown> {
+    return {
+      ...super.debugInfo,
+      kind: this.symbolKind,
+      accessibility: this.accessibility,
+      isAbstract: this.isAbstract,
+      isVirtual: this.isVirtual,
+      isOverride: this.isOverride,
+      isStatic: this.isStatic,
+      isSealed: this.isSealed,
+      isExtern: this.isExtern,
+      isReadOnly: this.isReadOnly,
+      isNullable: this.isNullable,
+    };
+  }
+
   /**
    * Whether this symbol is static.
    */

package/src/symbols/factories.ts

@@ -1,4 +1,5 @@
 import {
+  createSymbol,
   Namekey,
   NamePolicyGetter,
   onCleanup,
@@ -37,11 +38,11 @@ export function createParameterSymbol(
       `Can't create parameter symbol outside of a method or class scope.`,
     );
   }
-  return new CSharpSymbol(
-    originalName,
-    scope.parameters,
-    withNamePolicy(options, "parameter"),
-  );
+  const binder = options.binder ?? scope.binder;
+  return createSymbol(CSharpSymbol, originalName, scope.parameters, {
+    ...withNamePolicy(options, "parameter"),
+    binder,
+  });
 }
 
 export interface CreateTypeParameterSymbolOptions extends CSharpSymbolOptions {
@@ -61,11 +62,11 @@ export function createTypeParameterSymbol(
     );
   }
 
-  return new CSharpSymbol(
-    originalName,
-    scope.typeParameters,
-    withNamePolicy(options, "type-parameter"),
-  );
+  const binder = options.binder ?? scope.binder;
+  return createSymbol(CSharpSymbol, originalName, scope.typeParameters, {
+    ...withNamePolicy(options, "type-parameter"),
+    binder,
+  });
 }
 
 export function createFieldSymbol(
@@ -91,11 +92,11 @@ export function createFieldSymbol(
     throw new Error(`Can't define a field outside of a class or struct.`);
   }
 
-  return new CSharpSymbol(
-    originalName,
-    scope.members,
-    withNamePolicy(options, nameElement),
-  );
+  const binder = options.binder ?? scope.binder;
+  return createSymbol(CSharpSymbol, originalName, scope.members, {
+    ...withNamePolicy(options, nameElement),
+    binder,
+  });
 }
 
 function withCleanup<T extends CSharpSymbol>(sym: T): T {
@@ -111,8 +112,12 @@ export function createNamedTypeSymbol(
   options?: OutputSymbolOptions,
 ) {
   const scope = useNamedTypeScope();
+  const binder = options?.binder ?? scope.ownerSymbol.binder;
   return withCleanup(
-    new NamedTypeSymbol(name, scope.ownerSymbol.members, kind, options),
+    createSymbol(NamedTypeSymbol, name, scope.ownerSymbol.members, kind, {
+      ...options,
+      binder,
+    }),
   );
 }
 
@@ -121,7 +126,9 @@ export function createNamespaceSymbol(
   options: CSharpSymbolOptions = {},
 ): NamespaceSymbol {
   const scope = useNamespaceContext();
-  const parentSymbol = scope?.symbol ?? getGlobalNamespace(useBinder());
+  const parentSymbol =
+    scope?.symbol ??
+    getGlobalNamespace(options.binder ?? scope?.symbol?.binder ?? useBinder());
   const names = normalizeNamespaceName(name);
   let current = parentSymbol;
   for (const name of names) {
@@ -155,12 +162,12 @@ function createNamespaceSymbolInternal(
       expectedName,
     )! as NamespaceSymbol;
   }
+  const binder = options.binder ?? parentSymbol.binder;
   return withCleanup(
-    new NamespaceSymbol(
-      name,
-      parentSymbol,
-      withNamePolicy(options, "namespace"),
-    ),
+    createSymbol(NamespaceSymbol, name, parentSymbol, {
+      ...withNamePolicy(options, "namespace"),
+      binder,
+    }),
   );
 }
 
@@ -184,12 +191,17 @@ export function createMethodSymbol(
     );
   }
 
+  const binder = options.binder ?? scope.binder;
   return withCleanup(
-    new MethodSymbol(
+    createSymbol(
+      MethodSymbol,
       originalName,
       scope.members,
       options.methodKind ?? "ordinary",
-      withNamePolicy(options, "class-method"),
+      {
+        ...withNamePolicy(options, "class-method"),
+        binder,
+      },
     ),
   );
 }
@@ -199,12 +211,12 @@ export function createPropertySymbol(
   options: CSharpSymbolOptions,
 ) {
   const scope = useNamedTypeScope();
+  const binder = options.binder ?? scope.binder;
   return withCleanup(
-    new CSharpSymbol(
-      name,
-      scope.members,
-      withNamePolicy(options, "class-property"),
-    ),
+    createSymbol(CSharpSymbol, name, scope.members, {
+      ...withNamePolicy(options, "class-property"),
+      binder,
+    }),
   );
 }
 
@@ -232,12 +244,12 @@ export function createVariableSymbol(
       `Can't create variable symbol outside of a lexical scope, got a ${scope.constructor.name}.`,
     );
   }
+  const binder = options.binder ?? scope.binder;
   return withCleanup(
-    new CSharpSymbol(
-      originalName,
-      scope.localVariables,
-      withNamePolicy(options, "variable"),
-    ),
+    createSymbol(CSharpSymbol, originalName, scope.localVariables, {
+      ...withNamePolicy(options, "variable"),
+      binder,
+    }),
   );
 }
 

package/src/symbols/named-type.ts

@@ -1,4 +1,4 @@
-import { Namekey, OutputSpace } from "@alloy-js/core";
+import { Namekey, OutputSpace, createSymbol } from "@alloy-js/core";
 import { CSharpSymbol, CSharpSymbolOptions } from "./csharp.js";
 
 // represents a symbol from a .cs file. Class, enum, interface etc.
@@ -38,11 +38,16 @@ export class NamedTypeSymbol extends CSharpSymbol {
 
   copy() {
     const options = this.getCopyOptions();
-    const copy = new NamedTypeSymbol(
+    const binder = this.binder;
+    const copy = createSymbol(
+      NamedTypeSymbol,
       this.name,
       undefined,
       this.#typeKind,
-      options,
+      {
+        ...options,
+        binder,
+      },
     );
     this.initializeCopy(copy);
     return copy;
@@ -51,4 +56,11 @@ export class NamedTypeSymbol extends CSharpSymbol {
   get members() {
     return this.memberSpaceFor("members")!;
   }
+
+  override get debugInfo(): Record<string, unknown> {
+    return {
+      ...super.debugInfo,
+      typeKind: this.typeKind,
+    };
+  }
 }