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

package/src/components/method/method.tsx

@@ -2,7 +2,8 @@ import {
   Block,
   Children,
   MemberDeclaration,
-  refkey,
+  MemberName,
+  Namekey,
   Refkey,
   Scope,
 } from "@alloy-js/core";
@@ -13,9 +14,8 @@ import {
   getAsyncModifier,
   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 { createMethodScope } from "../../scopes/factories.js";
+import { createMethodSymbol } from "../../symbols/factories.js";
 import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 import { ParameterProps, Parameters } from "../parameters/parameters.jsx";
@@ -46,9 +46,12 @@ const getMethodModifier = makeModifiers<MethodModifiers>([
 
 // properties for creating a method
 export interface MethodProps extends AccessModifiers, MethodModifiers {
-  name: string;
+  name: string | Namekey;
   refkey?: Refkey;
   children?: Children;
+  /**
+   * An array of parameter descriptors.
+   */
   parameters?: Array<ParameterProps>;
   returns?: Children;
 
@@ -110,26 +113,12 @@ export interface MethodProps extends AccessModifiers, MethodModifiers {
 
 // a C# class method
 export function Method(props: MethodProps) {
-  const name = useCSharpNamePolicy().getName(props.name, "class-method");
-  const scope = useCSharpScope();
-  if (
-    scope.kind !== "member" ||
-    (scope.name !== "class-decl" && scope.name !== "struct-decl")
-  ) {
-    throw new Error(
-      "can't define a class method outside of a class or struct scope",
-    );
-  }
-
-  const methodSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
+  const methodSymbol = createMethodSymbol(props.name, {
+    refkeys: props.refkey,
   });
 
   // scope for method declaration
-  const methodScope = new CSharpMemberScope("method-decl", {
-    owner: methodSymbol,
-  });
+  const methodScope = createMethodScope();
 
   const returns = props.returns ?? (props.async ? "Task" : "void");
 
@@ -145,7 +134,7 @@ export function Method(props: MethodProps) {
         <DocWhen doc={props.doc} />
         <AttributeList attributes={props.attributes} endline />
         {modifiers}
-        {returns} {name}
+        {returns} <MemberName />
         {props.typeParameters && (
           <TypeParameters parameters={props.typeParameters} />
         )}

package/src/components/method-scope.tsx

@@ -0,0 +1,27 @@
+import { Scope, ScopePropsWithInfo, ScopePropsWithValue } from "@alloy-js/core";
+import { useCSharpScope } from "../scopes/contexts.js";
+import { CSharpMethodScope } from "../scopes/method.js";
+
+export interface MethodScopePropsWithScopeValue extends ScopePropsWithValue {}
+export interface MethodScopePropsWithScopeInfo extends ScopePropsWithInfo {}
+
+export type MethodScopeProps =
+  | MethodScopePropsWithScopeValue
+  | MethodScopePropsWithScopeInfo;
+
+export function MethodScope(props: MethodScopeProps) {
+  let scope;
+  if ("value" in props) {
+    if (!(props.value instanceof CSharpMethodScope)) {
+      throw new Error("MethodScope value must be a CSharpMethodScope instance");
+    }
+    scope = props.value;
+  } else {
+    const parentScope = useCSharpScope();
+    scope = new CSharpMethodScope(props.name ?? "method scope", parentScope, {
+      ...props,
+    });
+  }
+
+  return <Scope value={scope}>{props.children}</Scope>;
+}

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 "./source-file/source-file.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 "./source-file/source-file.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,117 @@
+import { ClassDeclaration } from "#components/class/declaration.jsx";
+import { Method } from "#components/method/method.jsx";
+import { Property } from "#components/property/property.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();
+        }
+    }
+  `);
+});
+
+it("members can be referenced when the parameter is nullable", () => {
+  const propTypeKey = namekey("PropType");
+  const propTypePropKey = namekey("Field");
+  const classKey = namekey("TestType");
+  const propKey = namekey("TestProp");
+  const param1Key = namekey("param1");
+
+  expect(
+    <TestNamespace>
+      <List>
+        <ClassDeclaration name={propTypeKey}>
+          <Property name={propTypePropKey} type={"string"} nullable />
+        </ClassDeclaration>
+        <ClassDeclaration name={classKey}>
+          <Property name={propKey} type={propTypeKey} nullable />
+        </ClassDeclaration>
+        <ClassDeclaration name="Test">
+          <Method
+            name="Test"
+            parameters={[{ name: param1Key, type: classKey, optional: true }]}
+          >
+            return {memberRefkey(param1Key, propKey, propTypePropKey)};
+          </Method>
+        </ClassDeclaration>
+      </List>
+    </TestNamespace>,
+  ).toRenderTo(`
+      class PropType
+      {
+          string? Field {  }
+      }
+      class TestType
+      {
+          PropType? TestProp {  }
+      }
+      class Test
+      {
+          void Test(TestType? param1)
+          {
+              return param1?.TestProp?.Field;
+          }
+      }
+  `);
+});

package/src/components/parameters/parameters.tsx

@@ -1,52 +1,40 @@
 import {
   Children,
   code,
+  createSymbolSlot,
   Declaration,
   For,
   Indent,
-  OutputSymbol,
-  refkey,
+  Namekey,
   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;
   /** Default value for the parameter */
   default?: Children;
+
   refkey?: Refkey;
-  symbol?: OutputSymbol;
 }
 
 /** 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,
+    isNullable: props.optional,
   });
 
   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; }
     }
   `);
 });