@alloy-js/csharp 0.16.0 → 0.18.0-dev.10

package/src/components/{Class.tsx → ClassDeclaration.tsx}

@@ -1,45 +1,81 @@
 import * as core from "@alloy-js/core";
 import {
-  AccessModifier,
+  AccessModifiers,
+  computeModifiersPrefix,
   getAccessModifier,
-  getMethodModifier,
-  MethodModifier,
+  makeModifiers,
 } from "../modifiers.js";
 import { CSharpElements, useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
-import { createCSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
-import { Name } from "./Name.js";
-import { ParameterProps, Parameters } from "./Parameters.js";
+import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
+import { Name } from "./Name.jsx";
+import { ParameterProps, Parameters } from "./Parameters.jsx";
+import { DocWhen } from "./doc/comment.jsx";
+
+export interface ClassModifiers {
+  readonly abstract?: boolean;
+  readonly partial?: boolean;
+  readonly sealed?: boolean;
+  readonly static?: boolean;
+}
+
+const getClassModifiers = makeModifiers<ClassModifiers>([
+  "abstract",
+  "partial",
+  "sealed",
+  "static",
+]);
 
 // properties for creating a class
-export interface ClassProps extends Omit<core.DeclarationProps, "nameKind"> {
+export interface ClassDeclarationProps
+  extends Omit<core.DeclarationProps, "nameKind">,
+    AccessModifiers,
+    ClassModifiers {
   name: string;
+  /** Doc comment */
+  doc?: core.Children;
   refkey?: core.Refkey;
-  accessModifier?: AccessModifier;
   typeParameters?: Record<string, core.Refkey>;
 }
 
-// a C# class declaration
-export function Class(props: ClassProps) {
+/**
+ * CSharp class declaration.
+ * @example
+ * ```tsx
+ * <ClassDeclaration public name="MyClass">
+ *   <ClassMember public name="MyField" type="int" />
+ *   <ClassConstructor>
+ *     <Parameter name="value" type="int" />
+ *     this.MyField = value;
+ *   </ClassConstructor>
+ * </ClassDeclaration>
+ * ```
+ * This will produce:
+ * ```csharp
+ * public class MyClass
+ * {
+ *   public int MyField;
+ *   public MyClass(int value)
+ *   {
+ *     this.MyField = value;
+ *   }
+ * }
+ * ```
+ */
+export function ClassDeclaration(props: ClassDeclarationProps) {
   const name = useCSharpNamePolicy().getName(props.name!, "class");
-  const scope = useCSharpScope();
 
-  const thisClassSymbol = scope.binder.createSymbol<CSharpOutputSymbol>({
-    name,
-    scope,
-    refkey: props.refkey,
+  const thisClassSymbol = new CSharpOutputSymbol(name, {
+    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 = createCSharpMemberScope(
-    scope.binder,
-    scope,
-    thisClassSymbol,
-    "class-decl",
-  );
+  const thisClassScope = new CSharpMemberScope("class-decl", {
+    owner: thisClassSymbol,
+  });
 
   let typeParams: core.Children;
   if (props.typeParameters) {
@@ -50,10 +86,9 @@ export function Class(props: ClassProps) {
       );
       // create a symbol for each type param so its
       // refkey resolves to the type param's name
-      scope.binder.createSymbol<CSharpOutputSymbol>({
-        name: entry[0],
+      new CSharpOutputSymbol(entry[0], {
         scope: thisClassScope,
-        refkey: entry[1],
+        refkeys: entry[1],
       });
     }
     typeParams = (
@@ -67,9 +102,14 @@ export function Class(props: ClassProps) {
     );
   }
 
+  const modifiers = computeModifiersPrefix([
+    getAccessModifier(props),
+    getClassModifiers(props),
+  ]);
   return (
     <core.Declaration symbol={thisClassSymbol}>
-      {getAccessModifier(props.accessModifier)}class <Name />
+      <DocWhen doc={props.doc} />
+      {modifiers}class <Name />
       {typeParams}
       {!props.children && ";"}
       {props.children && (
@@ -81,8 +121,7 @@ export function Class(props: ClassProps) {
   );
 }
 
-export interface ClassConstructorProps {
-  accessModifier?: AccessModifier;
+export interface ClassConstructorProps extends AccessModifiers {
   parameters?: Array<ParameterProps>;
   refkey?: core.Refkey;
   symbol?: core.OutputSymbol;
@@ -99,22 +138,19 @@ export function ClassConstructor(props: ClassConstructorProps) {
   }
 
   // fetch the class name from the scope
-  const name = useCSharpNamePolicy().getName(scope.owner.name, "class-method");
-  const ctorSymbol = scope.binder.createSymbol<CSharpOutputSymbol>({
-    name: name,
+  const name = useCSharpNamePolicy().getName(scope.owner!.name, "class-method");
+  const ctorSymbol = new CSharpOutputSymbol(name, {
     scope,
-    refkey: props.refkey ?? core.refkey(name),
+    refkeys: props.refkey ?? core.refkey(name),
   });
 
   // scope for ctor declaration
-  const ctorDeclScope = createCSharpMemberScope(
-    scope.binder,
-    scope,
-    ctorSymbol,
-    "constructor-decl",
-  );
+  const ctorDeclScope = new CSharpMemberScope("constructor-decl", {
+    owner: ctorSymbol,
+  });
+
+  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
 
-  const accessModifier = getAccessModifier(props.accessModifier);
   const params =
     props.parameters ? <Parameters parameters={props.parameters} /> : "";
 
@@ -122,7 +158,7 @@ export function ClassConstructor(props: ClassConstructorProps) {
   return (
     <core.Declaration symbol={ctorSymbol}>
       <core.Scope value={ctorDeclScope}>
-        {accessModifier}
+        {modifiers}
         <Name />({params})<core.Block newline>{props.children}</core.Block>
       </core.Scope>
     </core.Declaration>
@@ -130,17 +166,18 @@ export function ClassConstructor(props: ClassConstructorProps) {
 }
 
 // properties for creating a class member
-export interface ClassMemberProps {
+export interface ClassMemberProps extends AccessModifiers {
   name: string;
   type: core.Children;
-  accessModifier?: AccessModifier;
   refkey?: core.Refkey;
+  /** Doc comment */
+  doc?: core.Children;
 }
 
 // a C# class member (i.e. a field within a class like "private int count")
 export function ClassMember(props: ClassMemberProps) {
   let nameElement: CSharpElements = "class-member-private";
-  if (props.accessModifier === "public") {
+  if (props.public) {
     nameElement = "class-member-public";
   }
   const name = useCSharpNamePolicy().getName(props.name, nameElement);
@@ -151,68 +188,17 @@ export function ClassMember(props: ClassMemberProps) {
     );
   }
 
-  const memberSymbol = scope.binder.createSymbol<CSharpOutputSymbol>({
-    name: name,
+  const memberSymbol = new CSharpOutputSymbol(name, {
     scope,
-    refkey: props.refkey ?? core.refkey(props.name),
+    refkeys: props.refkey ?? core.refkey(props.name),
   });
 
+  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
   return (
     <core.Declaration symbol={memberSymbol}>
-      {getAccessModifier(props.accessModifier)}
+      <DocWhen doc={props.doc} />
+      {modifiers}
       {props.type} <Name />
     </core.Declaration>
   );
 }
-
-// properties for creating a method
-export interface ClassMethodProps {
-  name: string;
-  refkey?: core.Refkey;
-  children?: core.Children;
-  accessModifier?: AccessModifier;
-  methodModifier?: MethodModifier;
-  parameters?: Array<ParameterProps>;
-  returns?: core.Children;
-}
-
-// a C# class method
-export function ClassMethod(props: ClassMethodProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "class-method");
-  const scope = useCSharpScope();
-  if (scope.kind !== "member" || scope.name !== "class-decl") {
-    throw new Error("can't define a class method outside of a class scope");
-  }
-
-  const methodSymbol = scope.binder.createSymbol<CSharpOutputSymbol>({
-    name: name,
-    scope,
-    refkey: props.refkey ?? core.refkey(props.name),
-  });
-
-  // scope for method declaration
-  const methodScope = createCSharpMemberScope(
-    scope.binder,
-    scope,
-    methodSymbol,
-    "method-decl",
-  );
-
-  const accessModifier = getAccessModifier(props.accessModifier);
-  const methodModifier = getMethodModifier(props.methodModifier);
-  const params =
-    props.parameters ? <Parameters parameters={props.parameters} /> : "";
-  const returns = props.returns ?? "void";
-
-  // note that scope wraps the method decl so that the params get the correct scope
-  return (
-    <core.Declaration symbol={methodSymbol}>
-      <core.Scope value={methodScope}>
-        {accessModifier}
-        {methodModifier}
-        {returns} <Name />({params})
-        <core.Block newline>{props.children}</core.Block>
-      </core.Scope>
-    </core.Declaration>
-  );
-}

package/src/components/ClassMethod.tsx

@@ -0,0 +1,94 @@
+import {
+  Block,
+  Children,
+  MemberDeclaration,
+  refkey,
+  Refkey,
+  Scope,
+} from "@alloy-js/core";
+import {
+  AccessModifiers,
+  computeModifiersPrefix,
+  getAccessModifier,
+  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 { ParameterProps, Parameters } from "./Parameters.jsx";
+import { DocWhen } from "./doc/comment.jsx";
+
+/** Method modifiers. Can only be one. */
+export interface ClassMethodModifiers {
+  readonly abstract?: boolean;
+  readonly sealed?: boolean;
+  readonly static?: boolean;
+  readonly virtual?: boolean;
+}
+
+const getMethodModifier = makeModifiers<ClassMethodModifiers>([
+  "abstract",
+  "sealed",
+  "static",
+  "virtual",
+]);
+
+// properties for creating a method
+export interface ClassMethodProps
+  extends AccessModifiers,
+    ClassMethodModifiers {
+  name: string;
+  refkey?: Refkey;
+  children?: Children;
+  parameters?: Array<ParameterProps>;
+  returns?: Children;
+
+  /**
+   * If true, the method will be declared as an async method.
+   */
+  async?: boolean;
+
+  /** Doc comment */
+  doc?: Children;
+}
+
+// a C# class method
+export function ClassMethod(props: ClassMethodProps) {
+  const name = useCSharpNamePolicy().getName(props.name, "class-method");
+  const scope = useCSharpScope();
+  if (scope.kind !== "member" || scope.name !== "class-decl") {
+    throw new Error("can't define a class method outside of a class scope");
+  }
+
+  const methodSymbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? refkey(props.name),
+  });
+
+  // scope for method declaration
+  const methodScope = new CSharpMemberScope("method-decl", {
+    owner: methodSymbol,
+  });
+
+  const params =
+    props.parameters ? <Parameters parameters={props.parameters} /> : "";
+  const returns = props.returns ?? (props.async ? "Task" : "void");
+
+  const modifiers = computeModifiersPrefix([
+    getAccessModifier(props),
+    getMethodModifier(props),
+    getAsyncModifier(props.async),
+  ]);
+  // note that scope wraps the method decl so that the params get the correct scope
+  return (
+    <MemberDeclaration symbol={methodSymbol}>
+      <Scope value={methodScope}>
+        <DocWhen doc={props.doc} />
+        {modifiers}
+        {returns} {name}({params})
+        {props.abstract ? ";" : <Block newline>{props.children}</Block>}
+      </Scope>
+    </MemberDeclaration>
+  );
+}

package/src/components/Declaration.tsx

@@ -1,5 +1,5 @@
 import * as core from "@alloy-js/core";
-import { createCSharpSymbol } from "../symbols/csharp-output-symbol.js";
+import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
 
 // properties for creating a declaration
 export interface DeclarationProps {
@@ -10,6 +10,9 @@ export interface DeclarationProps {
 
 // declares a symbol in the program (class, enum, interface etc)
 export function Declaration(props: DeclarationProps) {
-  const sym = createCSharpSymbol(props);
+  const sym = new CSharpOutputSymbol(props.name, {
+    refkeys: props.refkey,
+  });
+
   return <core.Declaration symbol={sym}>{props.children}</core.Declaration>;
 }

package/src/components/EnumDeclaration.tsx

@@ -0,0 +1,99 @@
+import * as core from "@alloy-js/core";
+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 { Name } from "./Name.jsx";
+
+// properties for creating an enum
+export interface EnumDeclarationProps extends AccessModifiers {
+  name: string;
+  refkey?: core.Refkey;
+  children?: core.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 scope = useCSharpScope();
+
+  const thisEnumSymbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? core.refkey(props.name),
+  });
+
+  // this creates a new scope for the enum definition.
+  // members will automatically "inherit" this scope so
+  // that refkeys to them will produce the fully-qualified
+  // name e.g. Foo.Bar.
+  const thisEnumScope = new CSharpMemberScope("enum-decl", {
+    parent: scope,
+    owner: thisEnumSymbol,
+  });
+
+  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
+
+  if (thisEnumScope.owner)
+    return (
+      <core.Declaration symbol={thisEnumSymbol}>
+        {modifiers}enum <Name />
+        {!props.children && ";"}
+        {props.children && (
+          <core.Scope value={thisEnumScope}>
+            <core.Block newline>{props.children}</core.Block>
+          </core.Scope>
+        )}
+      </core.Declaration>
+    );
+}
+
+// properties for creating a C# enum member
+export interface EnumMemberProps {
+  name: string;
+  refkey?: core.Refkey;
+}
+
+// a member within a C# enum
+export function EnumMember(props: EnumMemberProps) {
+  const scope = useCSharpScope();
+  if (scope.kind === "member" && scope.name !== "enum-decl") {
+    throw new Error(
+      "can't define an enum member outside of an enum-decl scope",
+    );
+  }
+
+  const name = useCSharpNamePolicy().getName(props.name, "enum-member");
+  const thisEnumValueSymbol = new CSharpOutputSymbol(name, {
+    scope,
+    refkeys: props.refkey ?? core.refkey(props.name),
+  });
+
+  return (
+    <core.Declaration symbol={thisEnumValueSymbol}>
+      <Name />
+    </core.Declaration>
+  );
+}

package/src/components/Namespace.tsx

@@ -1,5 +1,5 @@
 import * as core from "@alloy-js/core";
-import { createCSharpNamespaceScope } from "../symbols/scopes.js";
+import { CSharpNamespaceScope } from "../symbols/scopes.js";
 
 // contains the info for the current namespace
 export interface NamespaceContext {
@@ -21,11 +21,7 @@ export interface NamespaceProps {
 
 // a C# namespace. contains one or more source files
 export function Namespace(props: NamespaceProps) {
-  const scope = createCSharpNamespaceScope(
-    core.useBinder(),
-    core.useScope(),
-    props.name,
-  );
+  const scope = new CSharpNamespaceScope(props.name);
 
   const namespaceCtx: NamespaceContext = {
     name: props.name,

package/src/components/Parameters.tsx

@@ -24,10 +24,9 @@ export function Parameter(props: ParameterProps) {
     );
   }
 
-  const memberSymbol = scope.binder.createSymbol<CSharpOutputSymbol>({
-    name: name,
+  const memberSymbol = new CSharpOutputSymbol(name, {
     scope,
-    refkey: props.refkey ?? core.refkey(props.name),
+    refkeys: props.refkey ?? core.refkey(props.name),
   });
 
   return (