@alloy-js/csharp 0.20.0-dev.3 → 0.20.0-dev.4

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

@@ -0,0 +1,139 @@
+import { Output, refkey } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { ClassDeclaration } from "./class/declaration.jsx";
+import { Namespace } from "./namespace.jsx";
+import { SourceFile } from "./SourceFile.jsx";
+
+it("references types in the same namespace", () => {
+  const classRef = refkey();
+
+  const tree = (
+    <Output>
+      <Namespace name="Test">
+        <SourceFile path="test.cs">
+          <ClassDeclaration name="TestClass" refkey={classRef} />
+          <hbr />
+          {classRef};
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(d`
+    namespace Test;
+
+    class TestClass;
+    TestClass;
+  `);
+});
+
+it("references types in a parent namespace", () => {
+  const classRef = refkey();
+
+  const tree = (
+    <Output>
+      <Namespace name="Test">
+        <SourceFile path="test.cs">
+          <ClassDeclaration name="TestClass" refkey={classRef} />
+          <hbr />
+          <Namespace name="Nested">{classRef};</Namespace>
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(d`
+    namespace Test {
+        class TestClass;
+        namespace Nested {
+            TestClass;
+        }
+    }
+  `);
+});
+
+it("references types in a child namespace", () => {
+  const classRef = refkey();
+
+  const tree = (
+    <Output>
+      <Namespace name="Test">
+        <SourceFile path="test.cs">
+          {classRef};<hbr />
+          <Namespace name="Nested">
+            <ClassDeclaration name="TestClass" refkey={classRef} />
+          </Namespace>
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(d`
+    namespace Test {
+        Nested.TestClass;
+        namespace Nested {
+            class TestClass;
+        }
+    }
+  `);
+});
+
+it("references types in a different top-level namespace declared in the same file", () => {
+  const classRef = refkey();
+
+  const tree = (
+    <Output>
+      <SourceFile path="test.cs">
+        <Namespace name="TestCode1">{classRef}</Namespace>
+        <hbr />
+        <Namespace name="TestCode2">
+          <ClassDeclaration name="TestClass" refkey={classRef} />
+        </Namespace>
+      </SourceFile>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(d`
+    using TestCode2;
+
+    namespace TestCode1 {
+        TestClass
+    }
+    namespace TestCode2 {
+        class TestClass;
+    }
+  `);
+});
+
+it("references types in a different top-level namespace declared in a different file", () => {
+  const classRef = refkey();
+
+  const tree = (
+    <Output>
+      <SourceFile path="test.cs">
+        <Namespace name="TestCode1">{classRef};</Namespace>
+      </SourceFile>
+      <SourceFile path="other.cs">
+        <Namespace name="TestCode2">
+          <ClassDeclaration name="TestClass" refkey={classRef} />
+        </Namespace>
+      </SourceFile>
+    </Output>
+  );
+
+  expect(tree).toRenderTo({
+    "test.cs": d`
+      using TestCode2;
+
+      namespace TestCode1 {
+          TestClass;
+      }
+    `,
+    "other.cs": d`
+        namespace TestCode2 {
+            class TestClass;
+        }
+      `,
+  });
+});

package/src/components/namespace.test.tsx

@@ -0,0 +1,52 @@
+import { Output } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { ClassDeclaration } from "./class/declaration.jsx";
+import { Namespace } from "./namespace.jsx";
+import { SourceFile } from "./SourceFile.jsx";
+
+it("defines multiple namespaces and source files with unique content", () => {
+  const tree = (
+    <Output>
+      <Namespace name="Namespace1">
+        <SourceFile path="Model1.cs">
+          <ClassDeclaration public name="Model1" />
+        </SourceFile>
+        <SourceFile path="Model2.cs">
+          <ClassDeclaration public name="Model2" />
+        </SourceFile>
+      </Namespace>
+      <Namespace name="Namespace2">
+        <SourceFile path="Model3.cs">
+          <ClassDeclaration public name="Model3" />
+        </SourceFile>
+        <SourceFile path="Model4.cs">
+          <ClassDeclaration public name="Model4" />
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo({
+    "Model1.cs": d`
+      namespace Namespace1;
+
+      public class Model1;
+    `,
+    "Model2.cs": d`
+      namespace Namespace1;
+
+      public class Model2;
+    `,
+    "Model3.cs": d`
+      namespace Namespace2;
+      
+      public class Model3;
+    `,
+    "Model4.cs": d`
+      namespace Namespace2;
+      
+      public class Model4;
+    `,
+  });
+});

package/src/components/namespace.tsx

@@ -0,0 +1,45 @@
+import { Block } from "@alloy-js/core";
+import { Children } from "@alloy-js/core/jsx-runtime";
+import { NamespaceContext } from "../contexts/namespace.js";
+import { useSourceFileScope } from "../scopes/source-file.js";
+import { createNamespaceSymbol } from "../symbols/factories.js";
+import { NamespaceScope } from "./namespace-scopes.jsx";
+
+export interface NamespaceProps {
+  name: string;
+  children?: Children;
+}
+
+export function Namespace(props: NamespaceProps) {
+  const namespaceSymbol = createNamespaceSymbol(props.name);
+  const sfScope = useSourceFileScope();
+
+  if (!sfScope) {
+    return (
+      <NamespaceContext.Provider value={{ symbol: namespaceSymbol }}>
+        {props.children}
+      </NamespaceContext.Provider>
+    );
+  } else {
+    sfScope.hasBlockNamespace = true;
+    return (
+      <>
+        namespace {namespaceSymbol.name}{" "}
+        <Block>
+          <NamespaceContext.Provider value={{ symbol: namespaceSymbol }}>
+            <NamespaceScope symbol={namespaceSymbol}>
+              {props.children}
+            </NamespaceScope>
+          </NamespaceContext.Provider>
+        </Block>
+      </>
+    );
+  }
+}
+
+/*
+  const scope = createCSharpNamespaceScope(namespaceSymbol);
+
+  return <Scope value={scope}>{props.children}</Scope>;
+}
+  */

package/src/components/parameters/parameters.test.tsx

@@ -0,0 +1,71 @@
+import { ClassDeclaration } from "#components/class/declaration.jsx";
+import { Method } from "#components/method/method.jsx";
+import { List, memberRefkey, namekey } from "@alloy-js/core";
+import { Children } from "@alloy-js/core/jsx-runtime";
+import { expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.jsx";
+
+const Wrapper = (props: { children: Children }) => (
+  <TestNamespace>
+    <ClassDeclaration public name="TestClass">
+      {props.children}
+    </ClassDeclaration>
+  </TestNamespace>
+);
+
+it("can be referenced", () => {
+  const param1Key = namekey("param1");
+  const param2Key = namekey("param2");
+  expect(
+    <Wrapper>
+      <Method
+        name="MethodOne"
+        parameters={[
+          { name: param1Key, type: "T1" },
+          { name: param2Key, type: "T2" },
+        ]}
+      />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+        void MethodOne(T1 param1, T2 param2) {}
+    }
+  `);
+});
+
+it("members can be referenced", () => {
+  const classKey = namekey("TestType");
+  const methodKey = namekey("TestMethod");
+  const param1Key = namekey("param1");
+
+  expect(
+    <TestNamespace>
+      <List>
+        <ClassDeclaration name={classKey}>
+          <Method name={methodKey} />
+        </ClassDeclaration>
+        <ClassDeclaration name="Test">
+          <Method
+            name="Test"
+            parameters={[{ name: param1Key, type: classKey }]}
+          >
+            return {memberRefkey(param1Key, methodKey)}();
+          </Method>
+        </ClassDeclaration>
+      </List>
+    </TestNamespace>,
+  ).toRenderTo(`
+    class TestType
+    {
+        void TestMethod() {}
+    }
+    class Test
+    {
+        void Test(TestType param1)
+        {
+            return param1.TestMethod();
+        }
+    }
+  `);
+});

package/src/components/parameters/parameters.tsx

@@ -1,20 +1,19 @@
 import {
   Children,
   code,
+  createSymbolSlot,
   Declaration,
   For,
   Indent,
+  Namekey,
   OutputSymbol,
-  refkey,
   Refkey,
 } from "@alloy-js/core";
-import { useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import { useCSharpMemberScope } from "../../symbols/scopes.js";
+import { createParameterSymbol } from "../../symbols/factories.js";
 import { Name } from "../Name.jsx";
 
 export interface ParameterProps {
-  name: string;
+  name: string | Namekey;
   type: Children;
   /** If the parmaeter is optional(without default value) */
   optional?: boolean;
@@ -26,22 +25,16 @@ export interface ParameterProps {
 
 /** Define a parameter to be used in class or interface method. */
 export function Parameter(props: ParameterProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "parameter");
-  const scope = useCSharpMemberScope([
-    "constructor-decl",
-    "method-decl",
-    "class-decl",
-    "record-decl",
-  ]);
+  const TypeSlot = createSymbolSlot();
 
-  const memberSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
+  const memberSymbol = createParameterSymbol(props.name, {
+    refkeys: props.refkey,
+    type: TypeSlot.firstSymbol,
   });
 
   return (
     <Declaration symbol={memberSymbol}>
-      {props.type}
+      <TypeSlot>{props.type}</TypeSlot>
       {props.optional ? "?" : ""} <Name />
       {props.default ? code` = ${props.default}` : ""}
     </Declaration>

package/src/components/property/property.test.tsx

@@ -30,7 +30,7 @@ describe("modifiers", () => {
         ).toRenderTo(`
         public class TestClass
         {
-          ${accessModifier} string TestProp { get; }
+            ${accessModifier} string TestProp { get; }
         }
       `);
       },
@@ -61,7 +61,7 @@ describe("modifiers", () => {
       ).toRenderTo(`
         public class TestClass
         {
-          ${methodModifier} string TestProp { get; }
+            ${methodModifier} string TestProp { get; }
         }
       `);
     });
@@ -75,7 +75,7 @@ describe("modifiers", () => {
     ).toRenderTo(`
         public class TestClass
         {
-          public new string TestProp { get; }
+            public new string TestProp { get; }
         }
       `);
   });
@@ -89,7 +89,7 @@ it("applies PascalCase naming policy", () => {
   ).toRenderTo(`
     public class TestClass
     {
-      string TestProp { get; }
+        string TestProp { get; }
     }
 `);
 });
@@ -102,7 +102,7 @@ it("has getter only", () => {
   ).toRenderTo(`
     public class TestClass
     {
-      string TestProp { get; }
+        string TestProp { get; }
     }
   `);
 });
@@ -115,7 +115,7 @@ it("has setter only", () => {
   ).toRenderTo(`
     public class TestClass
     {
-      string TestProp { set; }
+        string TestProp { set; }
     }
   `);
 });
@@ -128,7 +128,7 @@ it("has getter and setter", () => {
   ).toRenderTo(`
     public class TestClass
     {
-      string TestProp { get; set; }
+        string TestProp { get; set; }
     }
   `);
 });
@@ -141,7 +141,7 @@ it("has getter and init", () => {
   ).toRenderTo(`
     public class TestClass
     {
-      string TestProp { get; init; }
+        string TestProp { get; init; }
     }
   `);
 });
@@ -156,8 +156,8 @@ it("specify doc comment", () => {
   ).toRenderTo(`
     class Test
     {
-      /// This is a test
-      string Method { get; set; }
+        /// This is a test
+        string Method { get; set; }
     }
   `);
 });
@@ -170,7 +170,7 @@ it("specify nullable property", () => {
   ).toRenderTo(`
     public class TestClass
     {
-      string? TestProp { get; set; }
+        string? TestProp { get; set; }
     }
   `);
 });
@@ -183,7 +183,7 @@ it("specify initializer", () => {
   ).toRenderTo(`
     public class TestClass
     {
-      string TestProp { get; set; } = "abc";
+        string TestProp { get; set; } = "abc";
     }
   `);
 });
@@ -202,8 +202,8 @@ it("specify attributes", () => {
   ).toRenderTo(`
     public class TestClass
     {
-      [Test]
-      int Test { get; set; }
+        [Test]
+        int Test { get; set; }
     }
   `);
 });

package/src/components/property/property.tsx

@@ -4,9 +4,8 @@ import {
   code,
   List,
   MemberDeclaration,
-  refkey,
+  MemberName,
   Refkey,
-  Scope,
 } from "@alloy-js/core";
 import {
   AccessModifiers,
@@ -14,12 +13,7 @@ import {
   getAccessModifier,
   makeModifiers,
 } from "../../modifiers.js";
-import { useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import {
-  CSharpMemberScope,
-  useCSharpMemberScope,
-} from "../../symbols/scopes.js";
+import { createPropertySymbol } from "../../symbols/factories.js";
 import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 
@@ -121,21 +115,8 @@ export interface PropertyProps extends AccessModifiers, PropertyModifiers {
  * ```
  */
 export function Property(props: PropertyProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "class-property");
-  const scope = useCSharpMemberScope([
-    "class-decl",
-    "record-decl",
-    "struct-decl",
-  ]);
-
-  const propertySymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
-  });
-
-  // scope for property declaration
-  const propertyScope = new CSharpMemberScope("property-decl", {
-    owner: propertySymbol,
+  const propertySymbol = createPropertySymbol(props.name, {
+    refkeys: props.refkey,
   });
 
   const modifiers = computeModifiersPrefix([
@@ -151,21 +132,19 @@ export function Property(props: PropertyProps) {
   // note that scope wraps the method decl so that the params get the correct scope
   return (
     <MemberDeclaration symbol={propertySymbol}>
-      <Scope value={propertyScope}>
-        <DocWhen doc={props.doc} />
-        <AttributeList attributes={props.attributes} endline />
-        {modifiers}
-        {props.type}
-        {props.nullable && "?"} {name}{" "}
-        <Block newline inline>
-          <List joiner=" ">
-            {props.get && "get;"}
-            {props.set && "set;"}
-            {props.init && "init;"}
-          </List>
-        </Block>
-        {props.initializer && code` = ${props.initializer};`}
-      </Scope>
+      <DocWhen doc={props.doc} />
+      <AttributeList attributes={props.attributes} endline />
+      {modifiers}
+      {props.type}
+      {props.nullable && "?"} <MemberName />{" "}
+      <Block newline inline>
+        <List joiner=" ">
+          {props.get && "get;"}
+          {props.set && "set;"}
+          {props.init && "init;"}
+        </List>
+      </Block>
+      {props.initializer && code` = ${props.initializer};`}
     </MemberDeclaration>
   );
 }

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

@@ -2,15 +2,11 @@ import { Children, code, refkey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { Property } from "../property/property.jsx";
-import { SourceFile } from "../SourceFile.jsx";
 import { RecordDeclaration } from "./declaration.jsx";
 
+// Remove Wrapper that added <SourceFile> because TestNamespace already does
 function Wrapper({ children }: { children: Children }) {
-  return (
-    <TestNamespace>
-      <SourceFile path="Test.cs">{children}</SourceFile>
-    </TestNamespace>
-  );
+  return <TestNamespace>{children}</TestNamespace>;
 }
 
 it("declares record with no members", () => {
@@ -77,7 +73,7 @@ it("specify record property inside", () => {
     /// This is a test
     record TestRecord
     {
-      string Prop { get; set; }
+        string Prop { get; set; }
     }
   `);
 });
@@ -112,12 +108,9 @@ describe("constructor", () => {
         </RecordDeclaration>
       </Wrapper>,
     ).toRenderTo(`
-      namespace TestCode
+      public record Test(string name, int size)
       {
-          public record Test(string name, int size)
-          {
-              string PrettyName { get; } = $"{name} {size}";
-          }
+          string PrettyName { get; } = $"{name} {size}";
       }
   `);
   });

package/src/components/record/declaration.tsx

@@ -6,8 +6,11 @@ import {
   makeModifiers,
 } from "../../modifiers.js";
 import { useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import { CSharpMemberScope } from "../../symbols/scopes.js";
+import { createClassScope } from "../../scopes/factories.js";
+import {
+  createNamedTypeSymbol,
+  createTypeParameterSymbol,
+} from "../../symbols/factories.js";
 import { DocWhen } from "../doc/comment.jsx";
 import { Name } from "../Name.jsx";
 import { ParameterProps, Parameters } from "../parameters/parameters.jsx";
@@ -72,17 +75,13 @@ export interface RecordDeclarationProps
 export function RecordDeclaration(props: RecordDeclarationProps) {
   const name = useCSharpNamePolicy().getName(props.name!, "record");
 
-  const thisRecordSymbol = new CSharpOutputSymbol(name, {
+  // records don't have their own type kind but instead use class or struct
+  // depending on what kind of record we have.
+  const thisRecordSymbol = createNamedTypeSymbol(name, "record", {
     refkeys: props.refkey,
   });
 
-  // this creates a new scope for the record definition.
-  // members will automatically "inherit" this scope so
-  // that refkeys to them will produce the fully-qualified
-  // name e.g. Foo.Bar.
-  const thisRecordScope = new CSharpMemberScope("record-decl", {
-    owner: thisRecordSymbol,
-  });
+  const thisRecordScope = createClassScope(thisRecordSymbol);
 
   let typeParams: core.Children;
   if (props.typeParameters) {
@@ -93,7 +92,7 @@ export function RecordDeclaration(props: RecordDeclarationProps) {
       );
       // create a symbol for each type param so its
       // refkey resolves to the type param's name
-      new CSharpOutputSymbol(entry[0], {
+      createTypeParameterSymbol(entry[0], {
         scope: thisRecordScope,
         refkeys: entry[1],
       });