@alloy-js/csharp 0.23.0-dev.5 → 0.23.0-dev.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alloy-js/csharp",
-  "version": "0.23.0-dev.5",
+  "version": "0.23.0-dev.6",
   "description": "Alloy components for CSharp language.",
   "repository": {
     "type": "git",

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", () => {
@@ -141,3 +145,40 @@ it("define nested namespace in sourcefile", () => {
     }
   `);
 });
+
+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 />{" "}
+        namespace{" "}
+        <NamespaceName
+          symbol={namespaceSymbol}
+          relative={!!hasOuterNamespace}
+        />{" "}
         <Block>
-          <NamespaceContext.Provider value={{ symbol: namespaceSymbol }}>
-            <NamespaceScope symbol={namespaceSymbol}>
-              {props.children}
-            </NamespaceScope>
-          </NamespaceContext.Provider>
+          <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

@@ -162,3 +162,32 @@ it("can be referenced by refkey", () => {
     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;
+        }
+    }
+  `);
+});