@alloy-js/csharp 0.18.0-dev.2 → 0.18.0-dev.20

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

@@ -1,21 +1,91 @@
 import * as core from "@alloy-js/core";
-import { AccessModifier, getAccessModifier } from "../modifiers.js";
+import { join } 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 { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
-import { Name } from "./Name.js";
-import { ParameterProps, Parameters } from "./Parameters.js";
+import { Name } from "./Name.jsx";
+import { ParameterProps, Parameters } from "./Parameters.jsx";
+import { DocWhen } from "./doc/comment.jsx";
+import { TypeParameterConstraints } from "./type-parameters/type-parameter-constraints.jsx";
+import { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
+import { TypeParameters } from "./type-parameters/type-parameters.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>;
+
+  /**
+   * Type parameters for the class
+   *
+   * @example
+   * ```tsx
+   * <ClassDeclaration name="MyClass" typeParameters={["T"]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * public class MyClass<T>
+   * ```
+   */
+  typeParameters?: (string | TypeParameterProps)[];
+
+  /** Base class that this class extends */
+  baseType?: core.Children;
+
+  /** Interfaces this class implements */
+  interfaceTypes?: core.Children[];
 }
 
-// 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 thisClassSymbol = new CSharpOutputSymbol(name, {
@@ -30,35 +100,27 @@ export function Class(props: ClassProps) {
     owner: thisClassSymbol,
   });
 
-  let typeParams: core.Children;
-  if (props.typeParameters) {
-    const typeParamNames = new Array<string>();
-    for (const entry of Object.entries(props.typeParameters)) {
-      typeParamNames.push(
-        useCSharpNamePolicy().getName(entry[0], "type-parameter"),
-      );
-      // create a symbol for each type param so its
-      // refkey resolves to the type param's name
-      new CSharpOutputSymbol(entry[0], {
-        scope: thisClassScope,
-        refkeys: entry[1],
-      });
-    }
-    typeParams = (
-      <group>
-        {"<"}
-        <core.For each={typeParamNames} comma line>
-          {(name) => name}
-        </core.For>
-        {">"}
-      </group>
-    );
-  }
-
+  const bases = [
+    ...(props.baseType ? [props.baseType] : []),
+    ...(props.interfaceTypes || []),
+  ];
+  const base =
+    bases.length > 0 ? <> : {join(bases, { joiner: ", " })}</> : null;
+  const modifiers = computeModifiersPrefix([
+    getAccessModifier(props),
+    getClassModifiers(props),
+  ]);
   return (
     <core.Declaration symbol={thisClassSymbol}>
-      {getAccessModifier(props.accessModifier)}class <Name />
-      {typeParams}
+      <DocWhen doc={props.doc} />
+      {modifiers}class <Name />
+      {props.typeParameters && (
+        <TypeParameters parameters={props.typeParameters} />
+      )}
+      {base}
+      {props.typeParameters && (
+        <TypeParameterConstraints parameters={props.typeParameters} />
+      )}
       {!props.children && ";"}
       {props.children && (
         <core.Block newline>
@@ -69,8 +131,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;
@@ -98,7 +159,8 @@ export function ClassConstructor(props: ClassConstructorProps) {
     owner: ctorSymbol,
   });
 
-  const accessModifier = getAccessModifier(props.accessModifier);
+  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
+
   const params =
     props.parameters ? <Parameters parameters={props.parameters} /> : "";
 
@@ -106,7 +168,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>
@@ -114,17 +176,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);
@@ -140,9 +203,11 @@ export function ClassMember(props: ClassMemberProps) {
     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>
   );

package/src/components/ClassMethod.tsx

@@ -7,25 +7,43 @@ import {
   Scope,
 } from "@alloy-js/core";
 import {
-  AccessModifier,
+  AccessModifiers,
   computeModifiersPrefix,
   getAccessModifier,
   getAsyncModifier,
-  getMethodModifier,
-  MethodModifier,
+  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";
+import { TypeParameterConstraints } from "./type-parameters/type-parameter-constraints.jsx";
+import { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
+import { TypeParameters } from "./type-parameters/type-parameters.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 {
+export interface ClassMethodProps
+  extends AccessModifiers,
+    ClassMethodModifiers {
   name: string;
   refkey?: Refkey;
   children?: Children;
-  accessModifier?: AccessModifier;
-  methodModifier?: MethodModifier;
   parameters?: Array<ParameterProps>;
   returns?: Children;
 
@@ -33,6 +51,23 @@ export interface ClassMethodProps {
    * If true, the method will be declared as an async method.
    */
   async?: boolean;
+
+  /** Doc comment */
+  doc?: Children;
+
+  /**
+   * Type parameters for the method
+   *
+   * @example
+   * ```tsx
+   * <InterfaceMethod name="Test" typeParameters={["T"]} />
+   * ```
+   * This will produce:
+   * ```csharp
+   * public void Test<T>()
+   * ```
+   */
+  typeParameters?: (TypeParameterProps | string)[];
 }
 
 // a C# class method
@@ -58,19 +93,25 @@ export function ClassMethod(props: ClassMethodProps) {
   const returns = props.returns ?? (props.async ? "Task" : "void");
 
   const modifiers = computeModifiersPrefix([
-    getAccessModifier(props.accessModifier),
-    getMethodModifier(props.methodModifier),
+    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.methodModifier === "abstract" ?
-          ";"
-        : <Block newline>{props.children}</Block>}
+        {returns} {name}
+        {props.typeParameters && (
+          <TypeParameters parameters={props.typeParameters} />
+        )}
+        ({params})
+        {props.typeParameters && (
+          <TypeParameterConstraints parameters={props.typeParameters} />
+        )}
+        {props.abstract ? ";" : <Block newline>{props.children}</Block>}
       </Scope>
     </MemberDeclaration>
   );

package/src/components/{Enum.tsx → EnumDeclaration.tsx}

@@ -1,20 +1,42 @@
 import * as core from "@alloy-js/core";
-import { AccessModifier, getAccessModifier } from "../modifiers.js";
+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 EnumProps {
+export interface EnumDeclarationProps extends AccessModifiers {
   name: string;
   refkey?: core.Refkey;
   children?: core.Children;
-  accessModifier?: AccessModifier;
 }
 
-// a C# enum declaration
-export function Enum(props: EnumProps) {
+/**
+ * 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();
 
@@ -32,10 +54,12 @@ export function Enum(props: EnumProps) {
     owner: thisEnumSymbol,
   });
 
+  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
+
   if (thisEnumScope.owner)
     return (
       <core.Declaration symbol={thisEnumSymbol}>
-        {getAccessModifier(props.accessModifier)}enum <Name />
+        {modifiers}enum <Name />
         {!props.children && ";"}
         {props.children && (
           <core.Scope value={thisEnumScope}>

package/src/components/Parameters.tsx

@@ -1,4 +1,5 @@
 import * as core from "@alloy-js/core";
+import { code } from "@alloy-js/core";
 import { useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
 import { useCSharpScope } from "../symbols/scopes.js";
@@ -7,11 +8,15 @@ import { Name } from "./Name.js";
 export interface ParameterProps {
   name: string;
   type: core.Children;
+  /** If the parmaeter is optional(without default value) */
+  optional?: boolean;
+  /** Default value for the parameter */
+  default?: core.Children;
   refkey?: core.Refkey;
   symbol?: core.OutputSymbol;
 }
 
-// a constructor/method parameter
+/** 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();
@@ -31,14 +36,16 @@ export function Parameter(props: ParameterProps) {
 
   return (
     <core.Declaration symbol={memberSymbol}>
-      {props.type} <Name />
+      {props.type}
+      {props.optional ? "?" : ""} <Name />
+      {props.default ? code` = ${props.default}` : ""}
     </core.Declaration>
   );
 }
 
 export interface ParametersProps {
   // param name and type
-  parameters: Array<ParameterProps>;
+  parameters: ParameterProps[];
 }
 
 // a collection of parameters