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

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

@@ -1,3 +1,6 @@
+import { Constructor } from "#components/constructor/constructor.jsx";
+import { EnumDeclaration } from "#components/enum/declaration.jsx";
+import { EnumMember } from "#components/enum/member.jsx";
 import {
   Children,
   code,
@@ -6,28 +9,21 @@ import {
   NamePolicyContext,
   Output,
   refkey,
-  render,
 } from "@alloy-js/core";
 import * as coretest from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
-import { findFile, TestNamespace, toSourceText } from "../../../test/utils.jsx";
+import { TestNamespace, toSourceText } from "../../../test/utils.jsx";
 import { createCSharpNamePolicy } from "../../name-policy.js";
 import { Attribute } from "../attributes/attributes.jsx";
 import { Field } from "../field/field.jsx";
 import { Method } from "../method/method.jsx";
-import { Namespace } from "../Namespace.jsx";
 import { Property } from "../property/property.jsx";
-import { SourceFile } from "../SourceFile.jsx";
-import { Constructor, EnumDeclaration, EnumMember } from "../stc/index.js";
+import { SourceFile } from "../source-file/source-file.jsx";
 import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { ClassDeclaration } from "./declaration.jsx";
 
 function Wrapper({ children }: { children: Children }) {
-  return (
-    <TestNamespace>
-      <SourceFile path="Test.cs">{children}</SourceFile>
-    </TestNamespace>
-  );
+  return <TestNamespace>{children}</TestNamespace>;
 }
 
 it("declares class with no members", () => {
@@ -70,6 +66,24 @@ describe("modifiers", () => {
         public abstract partial class TestClass;
     `);
   });
+
+  it("places visibility, attributes, and modifiers in the correct order", () => {
+    expect(
+      <TestNamespace>
+        <ClassDeclaration
+          partial
+          public
+          abstract
+          sealed
+          name="TestClass"
+          attributes={[<Attribute name="Test" />]}
+        />
+      </TestNamespace>,
+    ).toRenderTo(`
+        [Test]
+        public abstract sealed partial class TestClass;
+    `);
+  });
 });
 
 describe("base", () => {
@@ -109,45 +123,43 @@ describe("base", () => {
 });
 
 it("declares class with some members", () => {
-  const res = toSourceText(
-    <ClassDeclaration public name="TestClass">
-      <List>
-        <Field public name="MemberOne" type="string" />
-        <Field public name="MemberTwo" type="int" />
-      </List>
-    </ClassDeclaration>,
+  const tree = (
+    <TestNamespace>
+      <ClassDeclaration public name="TestClass">
+        <List>
+          <Field public name="MemberOne" type="string" />
+          <Field public name="MemberTwo" type="int" />
+        </List>
+      </ClassDeclaration>
+    </TestNamespace>
   );
 
-  expect(res).toBe(coretest.d`
-    namespace TestCode
+  expect(tree).toRenderTo(coretest.d`
+    public class TestClass
     {
-        public class TestClass
-        {
-            public string MemberOne;
-            public int MemberTwo;
-        }
+        public string MemberOne;
+        public int MemberTwo;
     }
   `);
 });
 
 it("declares class with some methods", () => {
-  const res = toSourceText(
-    <ClassDeclaration public name="TestClass">
-      <List>
-        <Method public name="MethodOne" />
-        <Method private virtual name="MethodTwo" />
-      </List>
-    </ClassDeclaration>,
+  const tree = (
+    <TestNamespace>
+      <ClassDeclaration public name="TestClass">
+        <List>
+          <Method public name="MethodOne" />
+          <Method private virtual name="MethodTwo" />
+        </List>
+      </ClassDeclaration>
+    </TestNamespace>
   );
 
-  expect(res).toBe(coretest.d`
-    namespace TestCode
+  expect(tree).toRenderTo(coretest.d`
+    public class TestClass
     {
-        public class TestClass
-        {
-            public void MethodOne() {}
-            private virtual void MethodTwo() {}
-        }
+        public void MethodOne() {}
+        private virtual void MethodTwo() {}
     }
   `);
 });
@@ -168,59 +180,52 @@ it("uses refkeys for members, params, and return type", () => {
     },
   ];
 
-  const res = render(
+  expect(
     <Output namePolicy={createCSharpNamePolicy()}>
-      <Namespace name="TestCode">
-        <SourceFile path="Test.cs">
-          <EnumDeclaration public name="TestEnum" refkey={enumTypeRefkey}>
-            <List comma hardline>
-              <EnumMember name="One" />
-              <EnumMember name="Two" />
-            </List>
-          </EnumDeclaration>
-          <hbr />
-          <ClassDeclaration public name="TestInput" refkey={inputTypeRefkey} />
+      <SourceFile path="Test.cs">
+        <EnumDeclaration public name="TestEnum" refkey={enumTypeRefkey}>
+          <List comma hardline>
+            <EnumMember name="One" />
+            <EnumMember name="Two" />
+          </List>
+        </EnumDeclaration>
+        <hbr />
+        <ClassDeclaration public name="TestInput" refkey={inputTypeRefkey} />
+        <hbr />
+        <ClassDeclaration
+          public
+          name="TestResult"
+          refkey={testResultTypeRefkey}
+        />
+        <hbr />
+        <ClassDeclaration public name="TestClass">
+          <Field private name="MemberOne" type={enumTypeRefkey} />
           <hbr />
-          <ClassDeclaration
+          <Method
             public
-            name="TestResult"
-            refkey={testResultTypeRefkey}
-          />
-          <hbr />
-          <ClassDeclaration public name="TestClass">
-            <Field private name="MemberOne" type={enumTypeRefkey} />
-            <hbr />
-            <Method
-              public
-              name="MethodOne"
-              parameters={params}
-              returns={testResultTypeRefkey}
-            >
-              return new {testResultTypeRefkey}();
-            </Method>
-          </ClassDeclaration>
-        </SourceFile>
-      </Namespace>
+            name="MethodOne"
+            parameters={params}
+            returns={testResultTypeRefkey}
+          >
+            return new {testResultTypeRefkey}();
+          </Method>
+        </ClassDeclaration>
+      </SourceFile>
     </Output>,
-  );
-
-  expect(findFile(res, "Test.cs").contents).toBe(coretest.d`
-    namespace TestCode
+  ).toRenderTo(`
+    public enum TestEnum
     {
-        public enum TestEnum
-        {
-            One,
-            Two
-        }
-        public class TestInput;
-        public class TestResult;
-        public class TestClass
+        One,
+        Two
+    }
+    public class TestInput;
+    public class TestResult;
+    public class TestClass
+    {
+        private TestEnum _memberOne;
+        public TestResult MethodOne(int intParam, TestInput bodyParam)
         {
-            private TestEnum _memberOne;
-            public TestResult MethodOne(int intParam, TestInput bodyParam)
-            {
-                return new TestResult();
-            }
+            return new TestResult();
         }
     }
   `);
@@ -241,27 +246,22 @@ describe("with type parameters", () => {
 
     expect(
       <TestNamespace>
-        <SourceFile path="Test.cs">
-          <ClassDeclaration
-            public
-            name="TestClass"
-            typeParameters={typeParameters}
-          >
-            <List>
-              <Property name="PropA" type={typeParameters[0].refkey} get set />
-              <Property name="PropB" type={typeParameters[1].refkey} get set />
-            </List>
-          </ClassDeclaration>
-        </SourceFile>
+        <ClassDeclaration
+          public
+          name="TestClass"
+          typeParameters={typeParameters}
+        >
+          <List>
+            <Property name="PropA" type={typeParameters[0].refkey} get set />
+            <Property name="PropB" type={typeParameters[1].refkey} get set />
+          </List>
+        </ClassDeclaration>
       </TestNamespace>,
     ).toRenderTo(`
-      namespace TestCode
+      public class TestClass<T, U>
       {
-          public class TestClass<T, U>
-          {
-              T PropA { get; set; }
-              U PropB { get; set; }
-          }
+          T PropA { get; set; }
+          U PropB { get; set; }
       }
     `);
   });
@@ -290,10 +290,10 @@ describe("with type parameters", () => {
       </TestNamespace>,
     ).toRenderTo(`
       public class TestClass<T, U>
-        where T : IFoo
-        where U : IBar
+          where T : IFoo
+          where U : IBar
       {
-        // Body
+          // Body
       }
     `);
   });
@@ -308,25 +308,24 @@ it("declares class with invalid members", () => {
   );
 
   expect(() => toSourceText(decl)).toThrow(
-    "can't define an enum member outside of an enum-decl scope",
+    "EnumMember must be used within an EnumDeclaration.",
   );
 });
 
 describe("constructor", () => {
   it("declares with constructor", () => {
-    const res = toSourceText(
-      <ClassDeclaration public name="TestClass">
-        <Constructor public />
-      </ClassDeclaration>,
+    const tree = (
+      <TestNamespace>
+        <ClassDeclaration public name="TestClass">
+          <Constructor public />
+        </ClassDeclaration>
+      </TestNamespace>
     );
 
-    expect(res).toBe(coretest.d`
-    namespace TestCode
+    expect(tree).toRenderTo(coretest.d`
+    public class TestClass
     {
-        public class TestClass
-        {
-            public TestClass() {}
-        }
+        public TestClass() {}
     }
   `);
   });
@@ -350,33 +349,32 @@ describe("constructor", () => {
       },
     ];
 
-    const res = toSourceText(
-      <ClassDeclaration public name="TestClass">
-        <Field private name="name" type="string" refkey={thisNameRefkey} />
-        <hbr />
-        <Field private name="size" type="int" refkey={thisSizeRefkey} />
-        <hbr />
-        <Constructor public parameters={ctorParams}>
-          {thisNameRefkey} = {paramNameRefkey};<hbr />
-          {thisSizeRefkey} = {paramSizeRefkey};
-        </Constructor>
-      </ClassDeclaration>,
+    const tree = (
+      <TestNamespace>
+        <ClassDeclaration public name="TestClass">
+          <Field private name="name" type="string" refkey={thisNameRefkey} />
+          <hbr />
+          <Field private name="size" type="int" refkey={thisSizeRefkey} />
+          <hbr />
+          <Constructor public parameters={ctorParams}>
+            {thisNameRefkey} = {paramNameRefkey};<hbr />
+            {thisSizeRefkey} = {paramSizeRefkey};
+          </Constructor>
+        </ClassDeclaration>
+      </TestNamespace>
     );
 
     // TODO: assignments to members should have this. prefix
     // e.g. this.name = name;
-    expect(res).toBe(coretest.d`
-    namespace TestCode
+    expect(tree).toRenderTo(coretest.d`
+    public class TestClass
     {
-        public class TestClass
+        private string _name;
+        private int _size;
+        public TestClass(string name, int size)
         {
-            private string _name;
-            private int _size;
-            public TestClass(string name, int size)
-            {
-                _name = name;
-                _size = size;
-            }
+            _name = name;
+            _size = size;
         }
     }
   `);
@@ -415,12 +413,9 @@ describe("constructor", () => {
         </ClassDeclaration>
       </Wrapper>,
     ).toRenderTo(`
-      namespace TestCode
+      public class TestClass(string name, int size)
       {
-          public class TestClass(string name, int size)
-          {
-              string PrettyName { get; } = $"{name} {size}";
-          }
+          string PrettyName { get; } = $"{name} {size}";
       }
   `);
   });
@@ -441,12 +436,9 @@ describe("constructor", () => {
         </NamePolicyContext.Provider>
       </Wrapper>,
     ).toRenderTo(`
-      namespace TestCode
+      public class TestClass(string name)
       {
-          public class TestClass(string name)
-          {
-              string name_2;
-          }
+          string name_2;
       }
   `);
   });
@@ -474,8 +466,8 @@ it("supports class member doc comments", () => {
     /// This is a test
     class Test
     {
-      /// This is a member
-      public int Member;
+        /// This is a member
+        public int Member;
     }
   `);
 });

package/src/components/class/declaration.tsx

@@ -5,6 +5,7 @@ import {
   DeclarationProps,
   join,
   Name,
+  Namekey,
   Refkey,
   Scope,
 } from "@alloy-js/core";
@@ -14,9 +15,8 @@ import {
   getAccessModifier,
   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 } from "../../symbols/factories.js";
 import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { DocWhen } from "../doc/comment.jsx";
 import { ParameterProps, Parameters } from "../parameters/parameters.jsx";
@@ -33,9 +33,9 @@ export interface ClassModifiers {
 
 const getClassModifiers = makeModifiers<ClassModifiers>([
   "abstract",
-  "partial",
   "sealed",
   "static",
+  "partial",
 ]);
 
 // properties for creating a class
@@ -43,7 +43,7 @@ export interface ClassDeclarationProps
   extends Omit<DeclarationProps, "nameKind">,
     AccessModifiers,
     ClassModifiers {
-  name: string;
+  name: string | Namekey;
   /** Doc comment */
   doc?: Children;
   refkey?: Refkey;
@@ -130,19 +130,11 @@ export interface ClassDeclarationProps
  * ```
  */
 export function ClassDeclaration(props: ClassDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "class");
-
-  const thisClassSymbol = new CSharpOutputSymbol(name, {
+  const thisClassSymbol = createNamedTypeSymbol(props.name, "class", {
     refkeys: props.refkey,
   });
 
-  // this creates a new scope for the class definition.
-  // members will automatically "inherit" this scope so
-  // that refkeys to them will produce the fully-qualified
-  // name e.g. Foo.Bar.
-  const thisClassScope = new CSharpMemberScope("class-decl", {
-    owner: thisClassSymbol,
-  });
+  const thisClassScope = createClassScope(thisClassSymbol);
 
   const bases = [
     ...(props.baseType ? [props.baseType] : []),
@@ -159,24 +151,20 @@ export function ClassDeclaration(props: ClassDeclarationProps) {
       <DocWhen doc={props.doc} />
       <AttributeList attributes={props.attributes} endline />
       {modifiers}class <Name />
-      {props.typeParameters && (
-        <TypeParameters parameters={props.typeParameters} />
-      )}
-      {props.primaryConstructor && (
-        <Scope value={thisClassScope}>
+      <Scope value={thisClassScope}>
+        {props.typeParameters && (
+          <TypeParameters parameters={props.typeParameters} />
+        )}
+        {props.primaryConstructor && (
           <Parameters parameters={props.primaryConstructor} />
-        </Scope>
-      )}
-      {base}
-      {props.typeParameters && (
-        <TypeParameterConstraints parameters={props.typeParameters} />
-      )}
-      {!props.children && ";"}
-      {props.children && (
-        <Block newline>
-          <Scope value={thisClassScope}>{props.children}</Scope>
-        </Block>
-      )}
+        )}
+        {base}
+        {props.typeParameters && (
+          <TypeParameterConstraints parameters={props.typeParameters} />
+        )}
+        {!props.children && ";"}
+        {props.children && <Block newline>{props.children}</Block>}
+      </Scope>
     </Declaration>
   );
 }

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

@@ -2,7 +2,6 @@ import { refkey } from "@alloy-js/core";
 import { expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { ClassDeclaration } from "../class/declaration.jsx";
-import { SourceFile } from "../SourceFile.jsx";
 import { Constructor } from "./constructor.jsx";
 
 it("reference constructor parameters in body", () => {
@@ -16,25 +15,20 @@ it("reference constructor parameters in body", () => {
 
   expect(
     <TestNamespace>
-      <SourceFile path="Test.cs">
-        <ClassDeclaration public name="TestClass">
-          <Constructor public parameters={ctorParams}>
-            {paramNameRefkey};<hbr />
-            {paramSizeRefkey};
-          </Constructor>
-        </ClassDeclaration>
-      </SourceFile>
+      <ClassDeclaration public name="TestClass">
+        <Constructor public parameters={ctorParams}>
+          {paramNameRefkey};<hbr />
+          {paramSizeRefkey};
+        </Constructor>
+      </ClassDeclaration>
     </TestNamespace>,
   ).toRenderTo(`
-    namespace TestCode
+    public class TestClass
     {
-        public class TestClass
+        public TestClass(string name, int size)
         {
-            public TestClass(string name, int size)
-            {
-                name;
-                size;
-            }
+            name;
+            size;
         }
     }
   `);

package/src/components/constructor/constructor.tsx

@@ -1,20 +1,13 @@
-import {
-  Block,
-  Declaration,
-  Name,
-  Refkey,
-  refkey,
-  Scope,
-} from "@alloy-js/core";
+import { MethodScope } from "#components/method-scope.jsx";
+import { Block, MemberDeclaration, MemberName, Refkey } from "@alloy-js/core";
 import { Children } from "@alloy-js/core/jsx-runtime";
 import {
   AccessModifiers,
   computeModifiersPrefix,
   getAccessModifier,
 } 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 { useNamedTypeScope } from "../../scopes/contexts.js";
+import { MethodSymbol } from "../../symbols/method.js";
 import { ParameterProps, Parameters } from "../parameters/parameters.jsx";
 
 /**
@@ -32,36 +25,24 @@ export interface ConstructorProps extends AccessModifiers {
 }
 
 export function Constructor(props: ConstructorProps) {
-  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 scope = useNamedTypeScope();
 
-  const name = useCSharpNamePolicy().getName(scope.owner!.name, "class-method");
-  const ctorSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(name),
-  });
+  const name = scope.ownerSymbol.name;
 
-  const ctorDeclScope = new CSharpMemberScope("constructor-decl", {
-    owner: ctorSymbol,
+  const ctorSymbol = new MethodSymbol(name, scope.members, "constructor", {
+    refkeys: props.refkey,
   });
 
   const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
 
   return (
-    <Declaration symbol={ctorSymbol}>
-      <Scope value={ctorDeclScope}>
+    <MemberDeclaration symbol={ctorSymbol}>
+      <MethodScope>
         {modifiers}
-        <Name />
+        <MemberName />
         <Parameters parameters={props.parameters} />
         <Block newline>{props.children}</Block>
-      </Scope>
-    </Declaration>
+      </MethodScope>
+    </MemberDeclaration>
   );
 }