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

package/src/components/constructor/constructor.test.tsx

@@ -2,6 +2,7 @@ import { refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { ClassDeclaration } from "../class/declaration.jsx";
+import { DocSummary } from "../doc/comment.jsx";
 import { Constructor } from "./constructor.jsx";
 
 it("reference constructor parameters in body", () => {
@@ -33,3 +34,93 @@ it("reference constructor parameters in body", () => {
     }
   `);
 });
+
+it("renders doc comment", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration public name="TestClass">
+        <Constructor
+          public
+          doc={<DocSummary>Creates a new instance</DocSummary>}
+        >
+          // body
+        </Constructor>
+      </ClassDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+        /// <summary>
+        /// Creates a new instance
+        /// </summary>
+        public TestClass()
+        {
+            // body
+        }
+    }
+  `);
+});
+
+it("renders : base() initializer", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration public name="DerivedClass" baseType="BaseClass">
+        <Constructor
+          public
+          parameters={[{ name: "name", type: "string" }]}
+          baseConstructor={["name"]}
+        >
+          // body
+        </Constructor>
+      </ClassDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    public class DerivedClass : BaseClass
+    {
+        public DerivedClass(string name) : base(name)
+        {
+            // body
+        }
+    }
+  `);
+});
+
+it("renders : this() initializer", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration public name="MyClass">
+        <Constructor public thisConstructor={["0", "0"]}>
+          // body
+        </Constructor>
+      </ClassDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    public class MyClass
+    {
+        public MyClass() : this(0, 0)
+        {
+            // body
+        }
+    }
+  `);
+});
+
+it("renders : base() with no arguments", () => {
+  expect(
+    <TestNamespace>
+      <ClassDeclaration public name="DerivedClass" baseType="BaseClass">
+        <Constructor public baseConstructor={[]}>
+          // body
+        </Constructor>
+      </ClassDeclaration>
+    </TestNamespace>,
+  ).toRenderTo(`
+    public class DerivedClass : BaseClass
+    {
+        public DerivedClass() : base()
+        {
+            // body
+        }
+    }
+  `);
+});

package/src/components/constructor/constructor.tsx

@@ -1,5 +1,12 @@
 import { MethodScope } from "#components/method-scope.jsx";
-import { Block, MemberDeclaration, MemberName, Refkey } from "@alloy-js/core";
+import {
+  Block,
+  For,
+  Indent,
+  MemberDeclaration,
+  MemberName,
+  Refkey,
+} from "@alloy-js/core";
 import { Children } from "@alloy-js/core/jsx-runtime";
 import {
   AccessModifiers,
@@ -8,6 +15,7 @@ import {
 } from "../../modifiers.js";
 import { useNamedTypeScope } from "../../scopes/contexts.js";
 import { MethodSymbol } from "../../symbols/method.js";
+import { DocWhen } from "../doc/comment.jsx";
 import { ParameterProps, Parameters } from "../parameters/parameters.jsx";
 
 /**
@@ -17,14 +25,57 @@ export interface ConstructorProps extends AccessModifiers {
   /** Constructor parameters */
   parameters?: ParameterProps[];
 
+  /** Doc comment */
+  doc?: Children;
+
   /** Refkey */
   refkey?: Refkey;
 
+  /**
+   * Arguments to pass to the base class constructor.
+   * Renders `: base(args)` between parameter list and body.
+   *
+   * @example
+   * ```tsx
+   * <Constructor public baseConstructor={["name", "42"]}>
+   * ```
+   * This will produce:
+   * ```csharp
+   * public MyClass(...) : base(name, 42)
+   * {
+   * }
+   * ```
+   */
+  baseConstructor?: Children[];
+
+  /**
+   * Arguments to pass to another constructor in the same class.
+   * Renders `: this(args)` between parameter list and body.
+   *
+   * @example
+   * ```tsx
+   * <Constructor public thisConstructor={["0", "0"]}>
+   * ```
+   * This will produce:
+   * ```csharp
+   * public MyClass() : this(0, 0)
+   * {
+   * }
+   * ```
+   */
+  thisConstructor?: Children[];
+
   /** Constructor body */
   children?: Children;
 }
 
 export function Constructor(props: ConstructorProps) {
+  if (props.baseConstructor && props.thisConstructor) {
+    throw new Error(
+      "Cannot use both 'baseConstructor' and 'thisConstructor' on the same constructor",
+    );
+  }
+
   const scope = useNamedTypeScope();
 
   const name = scope.ownerSymbol.name;
@@ -35,14 +86,48 @@ export function Constructor(props: ConstructorProps) {
 
   const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
 
+  const initializer =
+    props.baseConstructor ?
+      <ConstructorInitializer keyword="base" args={props.baseConstructor} />
+    : props.thisConstructor ?
+      <ConstructorInitializer keyword="this" args={props.thisConstructor} />
+    : null;
+
   return (
     <MemberDeclaration symbol={ctorSymbol}>
       <MethodScope>
+        <DocWhen doc={props.doc} />
         {modifiers}
         <MemberName />
         <Parameters parameters={props.parameters} />
+        {initializer}
         <Block newline>{props.children}</Block>
       </MethodScope>
     </MemberDeclaration>
   );
 }
+
+interface ConstructorInitializerProps {
+  keyword: "base" | "this";
+  args: Children[];
+}
+
+function ConstructorInitializer(props: ConstructorInitializerProps) {
+  return (
+    <group>
+      {" : "}
+      {props.keyword}(
+      <Indent nobreak>
+        <For each={props.args} joiner={", "}>
+          {(arg) => (
+            <>
+              <softline />
+              {arg}
+            </>
+          )}
+        </For>
+      </Indent>
+      <softline />)
+    </group>
+  );
+}

package/src/components/doc/from-markdown.tsx

@@ -17,7 +17,10 @@ function renderTokens(tokens: Token[]) {
       {tokens.map((token, index) => (
         <>
           <DocFromMarkedToken token={token} />
-          {token.type === "paragraph" && index !== tokens.length - 1 && <br />}
+          {
+            /*@once*/ token.type === "paragraph" &&
+              index !== tokens.length - 1 && <br />
+          }
         </>
       ))}
     </>

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

@@ -45,3 +45,23 @@ it("takes a namekey", () => {
     enum MyEnum;
   `);
 });
+
+it("renders doc comment", () => {
+  const res = toSourceText(
+    <EnumDeclaration public name="TestEnum" doc="This is a test enum">
+      <EnumMember name="One" />,<hbr />
+      <EnumMember name="Two" />
+    </EnumDeclaration>,
+  );
+
+  expect(res).toBe(d`
+    namespace TestCode;
+
+    /// This is a test enum
+    public enum TestEnum
+    {
+        One,
+        Two
+    }
+  `);
+});

package/src/components/enum/declaration.tsx

@@ -14,11 +14,14 @@ import {
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { createNamedTypeScope } from "../../scopes/factories.js";
 import { createNamedTypeSymbol } from "../../symbols/factories.js";
+import { DocWhen } from "../doc/comment.jsx";
 import { Name } from "../Name.jsx";
 
 // properties for creating an enum
 export interface EnumDeclarationProps extends AccessModifiers {
   name: string | Namekey;
+  /** Doc comment */
+  doc?: Children;
   refkey?: Refkey | Refkey[];
   children?: Children;
 }
@@ -54,6 +57,7 @@ export function EnumDeclaration(props: EnumDeclarationProps) {
 
   return (
     <Declaration symbol={symbol}>
+      <DocWhen doc={props.doc} />
       {modifiers}enum <Name />
       {!props.children && ";"}
       {props.children && (

package/src/components/enum/member.test.tsx

@@ -43,3 +43,24 @@ it("takes a namekey", () => {
     Foo.MyMember;
   `);
 });
+
+it("renders doc comment", () => {
+  const res = toSourceText(
+    <EnumDeclaration public name="TestEnum">
+      <EnumMember name="One" doc="First value" />,<hbr />
+      <EnumMember name="Two" doc="Second value" />
+    </EnumDeclaration>,
+  );
+
+  expect(res).toBe(d`
+    namespace TestCode;
+
+    public enum TestEnum
+    {
+        /// First value
+        One,
+        /// Second value
+        Two
+    }
+  `);
+});

package/src/components/enum/member.tsx

@@ -1,11 +1,21 @@
-import { MemberDeclaration, MemberName, Namekey, Refkey } from "@alloy-js/core";
+import {
+  Children,
+  createSymbol,
+  MemberDeclaration,
+  MemberName,
+  Namekey,
+  Refkey,
+} from "@alloy-js/core";
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { useNamedTypeScope } from "../../scopes/contexts.js";
 import { CSharpSymbol } from "../../symbols/csharp.js";
+import { DocWhen } from "../doc/comment.jsx";
 
 // properties for creating a C# enum member
 export interface EnumMemberProps {
   name: string | Namekey;
+  /** Doc comment */
+  doc?: Children;
   refkey?: Refkey;
 }
 
@@ -23,13 +33,19 @@ export function EnumMember(props: EnumMemberProps) {
     throw new Error("EnumMember must be used within an EnumDeclaration.");
   }
 
-  const thisEnumValueSymbol = new CSharpSymbol(props.name, symbol.members, {
-    refkeys: props.refkey,
-    namePolicy: useCSharpNamePolicy().for("enum-member"),
-  });
+  const thisEnumValueSymbol = createSymbol(
+    CSharpSymbol,
+    props.name,
+    symbol.members,
+    {
+      refkeys: props.refkey,
+      namePolicy: useCSharpNamePolicy().for("enum-member"),
+    },
+  );
 
   return (
     <MemberDeclaration symbol={thisEnumValueSymbol}>
+      <DocWhen doc={props.doc} />
       <MemberName />
     </MemberDeclaration>
   );

package/src/components/lexical-scope.tsx

@@ -1,4 +1,9 @@
-import { Scope, ScopePropsWithInfo, ScopePropsWithValue } from "@alloy-js/core";
+import {
+  Scope,
+  ScopePropsWithInfo,
+  ScopePropsWithValue,
+  createScope,
+} from "@alloy-js/core";
 import { useCSharpScope } from "../scopes/contexts.js";
 import { CSharpLexicalScope } from "../scopes/lexical.js";
 
@@ -20,9 +25,15 @@ export function LexicalScope(props: LexicalScopeProps) {
     scope = props.value;
   } else {
     const parentScope = useCSharpScope();
-    scope = new CSharpLexicalScope(props.name ?? "lexical scope", parentScope, {
-      ...props,
-    });
+    scope = createScope(
+      CSharpLexicalScope,
+      props.name ?? "lexical scope",
+      parentScope,
+      {
+        ...props,
+        binder: parentScope?.binder,
+      },
+    );
   }
 
   return <Scope value={scope}>{props.children}</Scope>;

package/src/components/method-scope.tsx

@@ -1,4 +1,9 @@
-import { Scope, ScopePropsWithInfo, ScopePropsWithValue } from "@alloy-js/core";
+import {
+  Scope,
+  ScopePropsWithInfo,
+  ScopePropsWithValue,
+  createScope,
+} from "@alloy-js/core";
 import { useCSharpScope } from "../scopes/contexts.js";
 import { CSharpMethodScope } from "../scopes/method.js";
 
@@ -18,9 +23,15 @@ export function MethodScope(props: MethodScopeProps) {
     scope = props.value;
   } else {
     const parentScope = useCSharpScope();
-    scope = new CSharpMethodScope(props.name ?? "method scope", parentScope, {
-      ...props,
-    });
+    scope = createScope(
+      CSharpMethodScope,
+      props.name ?? "method scope",
+      parentScope,
+      {
+        ...props,
+        binder: parentScope?.binder,
+      },
+    );
   }
 
   return <Scope value={scope}>{props.children}</Scope>;

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

@@ -1,9 +1,13 @@
 import { TestNamespace } from "#test/utils.jsx";
-import { Output } from "@alloy-js/core";
+import { Output, refkey } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
+import { createCSharpNamePolicy } from "../../name-policy.js";
 import { ClassDeclaration } from "../class/declaration.jsx";
+import { Constructor } from "../constructor/constructor.jsx";
+import { Field } from "../field/field.jsx";
 import { SourceFile } from "../source-file/source-file.jsx";
+import { StructDeclaration } from "../struct/declaration.jsx";
 import { Namespace } from "./namespace.jsx";
 
 it("defines multiple namespaces and source files with unique content", () => {
@@ -134,10 +138,50 @@ it("define nested namespace in sourcefile", () => {
   );
 
   expect(tree).toRenderTo(`
-    namespace Base {
-        namespace Namespace1.Namespace2 {
+    namespace Base
+    {
+        namespace Namespace1.Namespace2
+        {
             public class Model1;
         }
     }
   `);
 });
+
+it("contains a struct with a private field initialized by a constructor", () => {
+  const fieldRefkey = refkey();
+  const paramRefkey = refkey();
+
+  const tree = (
+    <Output namePolicy={createCSharpNamePolicy()}>
+      <SourceFile path="MyStruct.cs">
+        <Namespace name="TestNamespace.Test">
+          <StructDeclaration public name="MyStruct">
+            <Field private name="value" type="int" refkey={fieldRefkey} />
+            <hbr />
+            <Constructor
+              public
+              parameters={[{ name: "value", type: "int", refkey: paramRefkey }]}
+            >
+              {fieldRefkey} = {paramRefkey};
+            </Constructor>
+          </StructDeclaration>
+        </Namespace>
+      </SourceFile>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(d`
+    namespace TestNamespace.Test
+    {
+        public struct MyStruct
+        {
+            private int _value;
+            public MyStruct(int value)
+            {
+                _value = value;
+            }
+        }
+    }
+  `);
+});

package/src/components/namespace/namespace.tsx

@@ -1,9 +1,12 @@
 import { Block, Namekey, Refkey } from "@alloy-js/core";
 import { Children } from "@alloy-js/core/jsx-runtime";
-import { NamespaceContext } from "../../contexts/namespace.js";
+import {
+  NamespaceContext,
+  useNamespaceContext,
+} from "../../contexts/namespace.js";
 import { useSourceFileScope } from "../../scopes/source-file.js";
 import { createNamespaceSymbol } from "../../symbols/factories.js";
-import { NamespaceScope } from "../namespace-scopes.jsx";
+import { NamespaceScopes } from "../namespace-scopes.jsx";
 import { NamespaceName } from "./namespace-name.jsx";
 
 export interface NamespaceProps {
@@ -25,16 +28,21 @@ export function Namespace(props: NamespaceProps) {
       </NamespaceContext.Provider>
     );
   } else {
+    const nsContext = useNamespaceContext();
+    const hasOuterNamespace = nsContext && !nsContext.symbol.isGlobal;
+
     sfScope.hasBlockNamespace = true;
     return (
       <>
-        namespace <NamespaceName symbol={namespaceSymbol} relative />{" "}
-        <Block>
-          <NamespaceContext.Provider value={{ symbol: namespaceSymbol }}>
-            <NamespaceScope symbol={namespaceSymbol}>
-              {props.children}
-            </NamespaceScope>
-          </NamespaceContext.Provider>
+        namespace{" "}
+        <NamespaceName
+          symbol={namespaceSymbol}
+          relative={!!hasOuterNamespace}
+        />
+        <Block newline>
+          <NamespaceScopes symbol={namespaceSymbol} stopAt={nsContext?.symbol}>
+            {props.children}
+          </NamespaceScopes>
         </Block>
       </>
     );

package/src/components/namespace-scopes.tsx

@@ -19,17 +19,41 @@ export function NamespaceScope(props: NamespaceScopProps) {
 }
 
 export interface NamespaceScopesProps {
+  /**
+   * Target namespace whose scope chain should be established for `children`.
+   *
+   * For dotted namespaces, this is typically the most nested segment symbol.
+   */
   symbol: NamespaceSymbol;
+
+  /**
+   * Optional ancestor namespace that is already in scope.
+   *
+   * Wrapping stops before this symbol to avoid duplicating existing namespace
+   * scopes in the reference chain.
+   */
+  stopAt?: NamespaceSymbol;
   children: Children;
 }
 
+/**
+ * Applies `NamespaceScope` wrappers from `symbol` up through its enclosing
+ * namespaces until the root (or `stopAt`, when provided).
+ */
 export function NamespaceScopes(props: NamespaceScopesProps) {
   function wrapWithScope(symbol: NamespaceSymbol, children: Children) {
+    if (symbol === props.stopAt) {
+      return children;
+    }
+
     const scopeChildren = (
       <NamespaceScope symbol={symbol}>{children}</NamespaceScope>
     );
 
-    if (symbol.enclosingNamespace) {
+    if (
+      symbol.enclosingNamespace &&
+      symbol.enclosingNamespace !== props.stopAt
+    ) {
       return wrapWithScope(symbol.enclosingNamespace, scopeChildren);
     }
 

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