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

package/src/components/namespace-scopes.tsx

@@ -0,0 +1,44 @@
+import { Scope } from "@alloy-js/core";
+import { Children } from "@alloy-js/core/jsx-runtime";
+import { NamespaceContext } from "../contexts/namespace.js";
+import { createCSharpNamespaceScope } from "../scopes/namespace.js";
+import { NamespaceSymbol } from "../symbols/namespace.js";
+
+export interface NamespaceScopProps {
+  symbol: NamespaceSymbol;
+  children: Children;
+}
+
+export function NamespaceScope(props: NamespaceScopProps) {
+  const scope = createCSharpNamespaceScope(props.symbol);
+  return (
+    <NamespaceContext.Provider value={{ symbol: props.symbol }}>
+      <Scope value={scope}>{props.children}</Scope>
+    </NamespaceContext.Provider>
+  );
+}
+
+export interface NamespaceScopesProps {
+  symbol: NamespaceSymbol;
+  children: Children;
+}
+
+export function NamespaceScopes(props: NamespaceScopesProps) {
+  function wrapWithScope(symbol: NamespaceSymbol, children: Children) {
+    const scopeChildren = (
+      <NamespaceScope symbol={symbol}>{children}</NamespaceScope>
+    );
+
+    if (symbol.enclosingNamespace) {
+      return wrapWithScope(symbol.enclosingNamespace, scopeChildren);
+    }
+
+    return scopeChildren;
+  }
+
+  return (
+    <NamespaceContext.Provider value={{ symbol: props.symbol }}>
+      {wrapWithScope(props.symbol, props.children)}
+    </NamespaceContext.Provider>
+  );
+}

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 { useCSharpScope } 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,27 +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 = useCSharpScope();
-  if (
-    scope.kind !== "member" ||
-    (scope.name !== "constructor-decl" &&
-      scope.name !== "method-decl" &&
-      scope.name !== "class-decl")
-  ) {
-    throw new Error(
-      "can't define a parameter outside of a constructor-decl or method-decl scope",
-    );
-  }
+  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,9 +13,7 @@ import {
   getAccessModifier,
   makeModifiers,
 } from "../../modifiers.js";
-import { useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import { CSharpMemberScope, useCSharpScope } from "../../symbols/scopes.js";
+import { createPropertySymbol } from "../../symbols/factories.js";
 import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 
@@ -118,27 +115,8 @@ export interface PropertyProps extends AccessModifiers, PropertyModifiers {
  * ```
  */
 export function Property(props: PropertyProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "class-property");
-  const scope = useCSharpScope();
-  if (
-    scope.kind !== "member" ||
-    (scope.name !== "class-decl" &&
-      scope.name !== "record-decl" &&
-      scope.name !== "struct-decl")
-  ) {
-    throw new Error(
-      "can't define an interface method outside of an interface scope",
-    );
-  }
-
-  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([
@@ -154,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

@@ -1,9 +1,15 @@
+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 { RecordDeclaration } from "./declaration.jsx";
 
-it("declares class with no members", () => {
+// Remove Wrapper that added <SourceFile> because TestNamespace already does
+function Wrapper({ children }: { children: Children }) {
+  return <TestNamespace>{children}</TestNamespace>;
+}
+
+it("declares record with no members", () => {
   expect(
     <TestNamespace>
       <RecordDeclaration name="TestRecord" />
@@ -56,7 +62,7 @@ it("specify doc comment", () => {
   `);
 });
 
-it("specify class property inside", () => {
+it("specify record property inside", () => {
   expect(
     <TestNamespace>
       <RecordDeclaration name="TestRecord" doc="This is a test">
@@ -67,7 +73,45 @@ it("specify class property inside", () => {
     /// This is a test
     record TestRecord
     {
-      string Prop { get; set; }
+        string Prop { get; set; }
     }
   `);
 });
+
+describe("constructor", () => {
+  it("declares primary constructor with args", () => {
+    const paramNameRefkey = refkey();
+    const paramSizeRefkey = refkey();
+
+    const ctorParams = [
+      {
+        name: "name",
+        type: "string",
+        refkey: paramNameRefkey,
+      },
+      {
+        name: "size",
+        type: "int",
+        refkey: paramSizeRefkey,
+      },
+    ];
+
+    expect(
+      <Wrapper>
+        <RecordDeclaration public name="Test" primaryConstructor={ctorParams}>
+          <Property
+            name="PrettyName"
+            type="string"
+            get
+            initializer={code`$"{${paramNameRefkey}} {${paramSizeRefkey}}"`}
+          />
+        </RecordDeclaration>
+      </Wrapper>,
+    ).toRenderTo(`
+      public record Test(string name, int size)
+      {
+          string PrettyName { get; } = $"{name} {size}";
+      }
+  `);
+  });
+});