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

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,10 @@ 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 +150,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>
   );
 }

package/src/components/enum/declaration.ref.test.tsx

@@ -0,0 +1,93 @@
+import { Namespace } from "#components/namespace.jsx";
+import { SourceFile } from "#components/SourceFile.jsx";
+import { Output, refkey } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { EnumDeclaration } from "./declaration.jsx";
+import { EnumMember } from "./member.jsx";
+
+it("can reference things by refkey", () => {
+  const enumRK = refkey();
+  const twoRK = refkey();
+
+  const tree = (
+    <Output>
+      <Namespace name="TestCode">
+        <SourceFile path="Test.cs">
+          <EnumDeclaration public name="TestEnum" refkey={enumRK}>
+            <EnumMember name="One" />,<hbr />
+            <EnumMember name="Two" refkey={twoRK} />
+          </EnumDeclaration>
+          <hbr />
+          {enumRK};<hbr />
+          {twoRK};
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+  expect(tree).toRenderTo(d`
+    namespace TestCode;
+
+    public enum TestEnum
+    {
+        One,
+        Two
+    }
+    TestEnum;
+    TestEnum.Two;
+  `);
+});
+
+it("can reference things by refkey across files", () => {
+  const enumRK = refkey();
+  const barRK = refkey();
+
+  const tree = (
+    <Output>
+      <Namespace name="TestCode">
+        <SourceFile path="Test.cs">
+          <EnumDeclaration public name="TestEnum">
+            <EnumMember name="One" />,<hbr />
+            <EnumMember name="Two" />
+          </EnumDeclaration>
+          <hbr />
+          {enumRK};<hbr />
+          {barRK};
+        </SourceFile>
+        <SourceFile path="Other.cs">
+          <EnumDeclaration public name="OtherEnum" refkey={enumRK}>
+            <EnumMember name="Foo" />,<hbr />
+            <EnumMember name="Bar" refkey={barRK} />
+          </EnumDeclaration>
+          <hbr />
+          {enumRK};<hbr />
+          {barRK};
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+  expect(tree).toRenderTo({
+    "Test.cs": d`
+      namespace TestCode;
+
+      public enum TestEnum
+      {
+          One,
+          Two
+      }
+      OtherEnum;
+      OtherEnum.Bar;
+    `,
+    "Other.cs": d`
+      namespace TestCode;
+
+      public enum OtherEnum
+      {
+          Foo,
+          Bar
+      }
+      OtherEnum;
+      OtherEnum.Bar;
+    `,
+  });
+});

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

@@ -0,0 +1,34 @@
+import { toSourceText } from "#test/utils.jsx";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { EnumDeclaration } from "./declaration.jsx";
+import { EnumMember } from "./member.jsx";
+
+it("declares enum with no members", () => {
+  const res = toSourceText(<EnumDeclaration public name="TestEnum" />);
+
+  expect(res).toBe(d`
+    namespace TestCode;
+
+    public enum TestEnum;
+  `);
+});
+
+it("applies naming policy to enum and members", () => {
+  const res = toSourceText(
+    <EnumDeclaration public name="testEnum">
+      <EnumMember name="one" />,<hbr />
+      <EnumMember name="two" />
+    </EnumDeclaration>,
+  );
+
+  expect(res).toBe(d`
+    namespace TestCode;
+
+    public enum TestEnum
+    {
+        One,
+        Two
+    }
+  `);
+});

package/src/components/enum/declaration.tsx

@@ -0,0 +1,65 @@
+import {
+  Block,
+  Children,
+  Declaration,
+  MemberScope,
+  Refkey,
+} from "@alloy-js/core";
+import {
+  AccessModifiers,
+  computeModifiersPrefix,
+  getAccessModifier,
+} from "../../modifiers.js";
+import { useCSharpNamePolicy } from "../../name-policy.js";
+import { createNamedTypeScope } from "../../scopes/factories.js";
+import { createNamedTypeSymbol } from "../../symbols/factories.js";
+import { Name } from "../Name.jsx";
+
+// properties for creating an enum
+export interface EnumDeclarationProps extends AccessModifiers {
+  name: string;
+  refkey?: Refkey | Refkey[];
+  children?: Children;
+}
+
+/**
+ * A C# enum declaration
+ * @example
+ * ```tsx
+ * <EnumDeclaration public name="Color">
+ *   <EnumMember name="Red" />
+ *   <EnumMember name="Green" />
+ *   <EnumMember name="Blue" />
+ * </EnumDeclaration>
+ * ```
+ * This will produce:
+ * ```csharp
+ * public enum Color
+ * {
+ *   Red,
+ *   Green,
+ *   Blue
+ * }
+ * ```
+ */
+export function EnumDeclaration(props: EnumDeclarationProps) {
+  const name = useCSharpNamePolicy().getName(props.name!, "enum");
+  const symbol = createNamedTypeSymbol(name, "enum", {
+    refkeys: props.refkey,
+  });
+  const scope = createNamedTypeScope(symbol);
+
+  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
+
+  return (
+    <Declaration symbol={symbol}>
+      {modifiers}enum <Name />
+      {!props.children && ";"}
+      {props.children && (
+        <MemberScope value={scope}>
+          <Block newline>{props.children}</Block>
+        </MemberScope>
+      )}
+    </Declaration>
+  );
+}

package/src/components/enum/member.test.tsx

@@ -0,0 +1,24 @@
+import { toSourceText } from "#test/utils.jsx";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { EnumDeclaration } from "./declaration.jsx";
+import { EnumMember } from "./member.jsx";
+
+it("declares enum with members", () => {
+  const res = toSourceText(
+    <EnumDeclaration public name="TestEnum">
+      <EnumMember name="One" />,<hbr />
+      <EnumMember name="Two" />
+    </EnumDeclaration>,
+  );
+
+  expect(res).toBe(d`
+    namespace TestCode;
+
+    public enum TestEnum
+    {
+        One,
+        Two
+    }
+  `);
+});

package/src/components/enum/member.tsx

@@ -0,0 +1,36 @@
+import { MemberDeclaration, MemberName, Refkey } from "@alloy-js/core";
+import { useCSharpNamePolicy } from "../../name-policy.js";
+import { useNamedTypeScope } from "../../scopes/contexts.js";
+import { CSharpSymbol } from "../../symbols/csharp.js";
+
+// properties for creating a C# enum member
+export interface EnumMemberProps {
+  name: string;
+  refkey?: Refkey;
+}
+
+// a member within a C# enum
+export function EnumMember(props: EnumMemberProps) {
+  const scope = useNamedTypeScope();
+
+  if (!scope) {
+    throw new Error("EnumMember must be used within an EnumDeclaration.");
+  }
+
+  const symbol = scope.ownerSymbol;
+
+  if (symbol.typeKind !== "enum") {
+    throw new Error("EnumMember must be used within an EnumDeclaration.");
+  }
+
+  const name = useCSharpNamePolicy().getName(props.name, "enum-member");
+  const thisEnumValueSymbol = new CSharpSymbol(name, symbol.members, {
+    refkeys: props.refkey,
+  });
+
+  return (
+    <MemberDeclaration symbol={thisEnumValueSymbol}>
+      <MemberName />
+    </MemberDeclaration>
+  );
+}

package/src/components/field/field.test.tsx

@@ -24,8 +24,8 @@ it("declares multiple fields", () => {
   ).toRenderTo(`
     public class TestClass
     {
-      public string MemberOne;
-      public int MemberTwo;
+        public string MemberOne;
+        public int MemberTwo;
     }
   `);
 });
@@ -46,7 +46,7 @@ describe("modifiers", () => {
         ).toRenderTo(`
         public class TestClass
         {
-          ${accessModifier} string ${accessModifier === "private" ? "_testProp" : "TestProp"};
+            ${accessModifier} string ${accessModifier === "private" ? "_testProp" : "TestProp"};
         }
       `);
       },
@@ -68,7 +68,7 @@ describe("modifiers", () => {
         ).toRenderTo(`
         public class TestClass
         {
-          ${methodModifier} string _testField;
+            ${methodModifier} string _testField;
         }
       `);
       },
@@ -83,7 +83,7 @@ describe("modifiers", () => {
     ).toRenderTo(`
         public class TestClass
         {
-          public new string TestField;
+            public new string TestField;
         }
       `);
   });
@@ -100,7 +100,7 @@ describe("naming", () => {
     ).toRenderTo(`
       public class TestClass
       {
-        public string MemberOne;
+          public string MemberOne;
       }
     `);
   });
@@ -115,7 +115,7 @@ describe("naming", () => {
     ).toRenderTo(`
     public class TestClass
     {
-      private string _memberOne;
+        private string _memberOne;
     }
   `);
   });

package/src/components/field/field.tsx

@@ -1,13 +1,15 @@
-import { Children, Declaration, Name, refkey, Refkey } from "@alloy-js/core";
+import { Children, Declaration, Name, Refkey } from "@alloy-js/core";
 import {
   AccessModifiers,
   computeModifiersPrefix,
   getAccessModifier,
   makeModifiers,
 } from "../../modifiers.js";
-import { CSharpElements, useCSharpNamePolicy } from "../../name-policy.js";
-import { CSharpOutputSymbol } from "../../symbols/csharp-output-symbol.js";
-import { useCSharpScope } from "../../symbols/scopes.js";
+import {
+  accessibilityFromProps,
+  nonAccessibilityFromProps,
+} from "../../symbols/csharp.js";
+import { createFieldSymbol } from "../../symbols/factories.js";
 import { DocWhen } from "../doc/comment.jsx";
 
 /** Field modifiers. */
@@ -35,25 +37,13 @@ export interface FieldProps extends AccessModifiers, FieldModifiers {
 
 /** Render a c# field */
 export function Field(props: FieldProps) {
-  let nameElement: CSharpElements = "class-member-private";
-  if (props.public || props.protected || props.internal) {
-    nameElement = "class-member-public";
-  }
-  const name = useCSharpNamePolicy().getName(props.name, nameElement);
-  const scope = useCSharpScope();
-  if (
-    scope.kind !== "member" ||
-    (scope.name !== "class-decl" && scope.name !== "struct-decl")
-  ) {
-    throw new Error(
-      "can't define a class member outside of a class or struct scope",
-    );
-  }
+  const options = {
+    accessibility: accessibilityFromProps(props),
+    refkeys: props.refkey,
+    ...nonAccessibilityFromProps(props),
+  };
 
-  const memberSymbol = new CSharpOutputSymbol(name, {
-    scope,
-    refkeys: props.refkey ?? refkey(props.name),
-  });
+  const memberSymbol = createFieldSymbol(props.name, options);
 
   const modifiers = computeModifiersPrefix([
     getAccessModifier(props),

package/src/components/index.ts

@@ -4,14 +4,17 @@ export * from "./constructor/constructor.jsx";
 export * from "./Declaration.js";
 export * from "./doc/comment.jsx";
 export * from "./doc/from-markdown.jsx";
-export * from "./EnumDeclaration.jsx";
+export * from "./enum/declaration.jsx";
+export * from "./enum/member.jsx";
 export * from "./field/field.jsx";
 export * from "./interface/declaration.js";
 export * from "./interface/method.js";
 export * from "./interface/property.js";
+export * from "./lexical-scope.jsx";
+export * from "./method-scope.jsx";
 export * from "./method/method.jsx";
 export * from "./Name.js";
-export * from "./Namespace.js";
+export * from "./namespace.js";
 export * from "./parameters/parameters.jsx";
 export * from "./ProjectDirectory.js";
 export * from "./property/property.jsx";

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

@@ -2,7 +2,6 @@ import { List, refkey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { Attribute } from "../attributes/attributes.jsx";
-import { SourceFile } from "../SourceFile.jsx";
 import { TypeParameterProps } from "../type-parameters/type-parameter.jsx";
 import { InterfaceDeclaration } from "./declaration.jsx";
 import { InterfaceProperty } from "./property.jsx";
@@ -75,37 +74,32 @@ describe("with type parameters", () => {
 
     expect(
       <TestNamespace>
-        <SourceFile path="Test.cs">
-          <InterfaceDeclaration
-            public
-            name="Test"
-            typeParameters={typeParameters}
-          >
-            <List>
-              <InterfaceProperty
-                name="PropA"
-                type={typeParameters[0].refkey}
-                get
-                set
-              />
-              <InterfaceProperty
-                name="PropB"
-                type={typeParameters[1].refkey}
-                get
-                set
-              />
-            </List>
-          </InterfaceDeclaration>
-        </SourceFile>
+        <InterfaceDeclaration
+          public
+          name="Test"
+          typeParameters={typeParameters}
+        >
+          <List>
+            <InterfaceProperty
+              name="PropA"
+              type={typeParameters[0].refkey}
+              get
+              set
+            />
+            <InterfaceProperty
+              name="PropB"
+              type={typeParameters[1].refkey}
+              get
+              set
+            />
+          </List>
+        </InterfaceDeclaration>
       </TestNamespace>,
     ).toRenderTo(`
-      namespace TestCode
+      public interface Test<T, U>
       {
-          public interface Test<T, U>
-          {
-              T PropA { get; set; }
-              U PropB { get; set; }
-          }
+          T PropA { get; set; }
+          U PropB { get; set; }
       }
     `);
   });
@@ -134,10 +128,10 @@ describe("with type parameters", () => {
       </TestNamespace>,
     ).toRenderTo(`
       public interface Test<T, U>
-        where T : IFoo
-        where U : IBar
+          where T : IFoo
+          where U : IBar
       {
-        // Body
+          // Body
       }
     `);
   });