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

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

@@ -1,91 +1,21 @@
 import * as core from "@alloy-js/core";
-import { join } from "@alloy-js/core";
-import {
-  AccessModifiers,
-  computeModifiersPrefix,
-  getAccessModifier,
-  makeModifiers,
-} from "../modifiers.js";
+import { AccessModifier, getAccessModifier } 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.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",
-]);
+import { Name } from "./Name.js";
+import { ParameterProps, Parameters } from "./Parameters.js";
 
 // properties for creating a class
-export interface ClassDeclarationProps
-  extends Omit<core.DeclarationProps, "nameKind">,
-    AccessModifiers,
-    ClassModifiers {
+export interface ClassProps extends Omit<core.DeclarationProps, "nameKind"> {
   name: string;
-  /** Doc comment */
-  doc?: core.Children;
   refkey?: 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[];
+  accessModifier?: AccessModifier;
+  typeParameters?: Record<string, core.Refkey>;
 }
 
-/**
- * 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) {
+// a C# class declaration
+export function Class(props: ClassProps) {
   const name = useCSharpNamePolicy().getName(props.name!, "class");
 
   const thisClassSymbol = new CSharpOutputSymbol(name, {
@@ -100,27 +30,35 @@ export function ClassDeclaration(props: ClassDeclarationProps) {
     owner: thisClassSymbol,
   });
 
-  const bases = [
-    ...(props.baseType ? [props.baseType] : []),
-    ...(props.interfaceTypes || []),
-  ];
-  const base =
-    bases.length > 0 ? <> : {join(bases, { joiner: ", " })}</> : null;
-  const modifiers = computeModifiersPrefix([
-    getAccessModifier(props),
-    getClassModifiers(props),
-  ]);
+  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>
+    );
+  }
+
   return (
     <core.Declaration symbol={thisClassSymbol}>
-      <DocWhen doc={props.doc} />
-      {modifiers}class <Name />
-      {props.typeParameters && (
-        <TypeParameters parameters={props.typeParameters} />
-      )}
-      {base}
-      {props.typeParameters && (
-        <TypeParameterConstraints parameters={props.typeParameters} />
-      )}
+      {getAccessModifier(props.accessModifier)}class <Name />
+      {typeParams}
       {!props.children && ";"}
       {props.children && (
         <core.Block newline>
@@ -131,7 +69,8 @@ export function ClassDeclaration(props: ClassDeclarationProps) {
   );
 }
 
-export interface ClassConstructorProps extends AccessModifiers {
+export interface ClassConstructorProps {
+  accessModifier?: AccessModifier;
   parameters?: Array<ParameterProps>;
   refkey?: core.Refkey;
   symbol?: core.OutputSymbol;
@@ -159,8 +98,7 @@ export function ClassConstructor(props: ClassConstructorProps) {
     owner: ctorSymbol,
   });
 
-  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
-
+  const accessModifier = getAccessModifier(props.accessModifier);
   const params =
     props.parameters ? <Parameters parameters={props.parameters} /> : "";
 
@@ -168,7 +106,7 @@ export function ClassConstructor(props: ClassConstructorProps) {
   return (
     <core.Declaration symbol={ctorSymbol}>
       <core.Scope value={ctorDeclScope}>
-        {modifiers}
+        {accessModifier}
         <Name />({params})<core.Block newline>{props.children}</core.Block>
       </core.Scope>
     </core.Declaration>
@@ -176,18 +114,17 @@ export function ClassConstructor(props: ClassConstructorProps) {
 }
 
 // properties for creating a class member
-export interface ClassMemberProps extends AccessModifiers {
+export interface ClassMemberProps {
   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.public) {
+  if (props.accessModifier === "public") {
     nameElement = "class-member-public";
   }
   const name = useCSharpNamePolicy().getName(props.name, nameElement);
@@ -203,11 +140,9 @@ export function ClassMember(props: ClassMemberProps) {
     refkeys: props.refkey ?? core.refkey(props.name),
   });
 
-  const modifiers = computeModifiersPrefix([getAccessModifier(props)]);
   return (
     <core.Declaration symbol={memberSymbol}>
-      <DocWhen doc={props.doc} />
-      {modifiers}
+      {getAccessModifier(props.accessModifier)}
       {props.type} <Name />
     </core.Declaration>
   );

package/src/components/ClassMethod.tsx

@@ -7,43 +7,25 @@ import {
   Scope,
 } from "@alloy-js/core";
 import {
-  AccessModifiers,
+  AccessModifier,
   computeModifiersPrefix,
   getAccessModifier,
   getAsyncModifier,
-  makeModifiers,
+  getMethodModifier,
+  MethodModifier,
 } 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
-  extends AccessModifiers,
-    ClassMethodModifiers {
+export interface ClassMethodProps {
   name: string;
   refkey?: Refkey;
   children?: Children;
+  accessModifier?: AccessModifier;
+  methodModifier?: MethodModifier;
   parameters?: Array<ParameterProps>;
   returns?: Children;
 
@@ -51,23 +33,6 @@ 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
@@ -93,25 +58,19 @@ export function ClassMethod(props: ClassMethodProps) {
   const returns = props.returns ?? (props.async ? "Task" : "void");
 
   const modifiers = computeModifiersPrefix([
-    getAccessModifier(props),
-    getMethodModifier(props),
+    getAccessModifier(props.accessModifier),
+    getMethodModifier(props.methodModifier),
     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}
-        {props.typeParameters && (
-          <TypeParameters parameters={props.typeParameters} />
-        )}
-        ({params})
-        {props.typeParameters && (
-          <TypeParameterConstraints parameters={props.typeParameters} />
-        )}
-        {props.abstract ? ";" : <Block newline>{props.children}</Block>}
+        {returns} {name}({params})
+        {props.methodModifier === "abstract" ?
+          ";"
+        : <Block newline>{props.children}</Block>}
       </Scope>
     </MemberDeclaration>
   );

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

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

package/src/components/Parameters.tsx

@@ -1,5 +1,4 @@
 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";
@@ -8,15 +7,11 @@ 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;
 }
 
-/** Define a parameter to be used in class or interface method. */
+// a constructor/method parameter
 export function Parameter(props: ParameterProps) {
   const name = useCSharpNamePolicy().getName(props.name, "parameter");
   const scope = useCSharpScope();
@@ -36,16 +31,14 @@ export function Parameter(props: ParameterProps) {
 
   return (
     <core.Declaration symbol={memberSymbol}>
-      {props.type}
-      {props.optional ? "?" : ""} <Name />
-      {props.default ? code` = ${props.default}` : ""}
+      {props.type} <Name />
     </core.Declaration>
   );
 }
 
 export interface ParametersProps {
   // param name and type
-  parameters: ParameterProps[];
+  parameters: Array<ParameterProps>;
 }
 
 // a collection of parameters

package/src/components/index.ts

@@ -1,20 +1,11 @@
-export * from "./ClassDeclaration.jsx";
-export * from "./ClassMethod.jsx";
+export * from "./Class.js";
+export { ClassMethod, type ClassMethodProps } from "./ClassMethod.jsx";
 export * from "./Declaration.js";
-export * from "./doc/comment.jsx";
-export * from "./doc/from-markdown.jsx";
-export * from "./EnumDeclaration.jsx";
-export * from "./interface/declaration.js";
-export * from "./interface/method.js";
-export * from "./interface/property.js";
+export * from "./Enum.js";
 export * from "./Name.js";
 export * from "./Namespace.js";
 export * from "./Parameters.js";
 export * from "./ProjectDirectory.js";
-export * from "./property/property.jsx";
-export * from "./record/declaration.js";
 export * from "./Reference.js";
 export * from "./SourceFile.js";
-export type { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
 export * from "./UsingDirective.js";
-export * from "./var/declaration.jsx";

package/src/components/stc/index.ts

@@ -1,11 +1,11 @@
 import * as core from "@alloy-js/core";
 import * as base from "../index.js";
 
-export const ClassDeclaration = core.stc(base.ClassDeclaration);
+export const Class = core.stc(base.Class);
 export const ClassConstructor = core.stc(base.ClassConstructor);
 export const ClassMember = core.stc(base.ClassMember);
 export const ClassMethod = core.stc(base.ClassMethod);
-export const EnumDeclaration = core.stc(base.EnumDeclaration);
+export const Enum = core.stc(base.Enum);
 export const EnumMember = core.stc(base.EnumMember);
 export const Parameter = core.stc(base.Parameter);
 export const Parameters = core.stc(base.Parameters);

package/src/modifiers.ts

@@ -1,25 +1,51 @@
 // the possible C# access modifiers
 // https://learn.microsoft.com/dotnet/csharp/programming-guide/classes-and-structs/access-modifiers
+export type AccessModifier =
+  | "public"
+  | "protected"
+  | "private"
+  | "internal"
+  | "protected-internal"
+  | "private-protected"
+  | "file";
 
-/** Access modifiers.  */
-export interface AccessModifiers {
-  readonly public?: boolean;
-  readonly protected?: boolean;
-  readonly private?: boolean;
-  readonly internal?: boolean;
-  readonly file?: boolean;
+// maps the above access modifier value to its C# syntax.
+// note that the C# keyword includes a trailing space
+const accessModifierLookup: Record<AccessModifier, string> = {
+  public: "public ",
+  protected: "protected ",
+  private: "private ",
+  internal: "internal ",
+  "protected-internal": "protected internal ",
+  "private-protected": "private protected ",
+  file: "file ",
+};
+
+// returns the C# syntax for the specified access modifier.
+// if no access modifier is specified, the empty string is returned.
+export function getAccessModifier(accessModifier?: AccessModifier): string {
+  return accessModifier ? accessModifierLookup[accessModifier] : "";
 }
 
-export const getAccessModifier = makeModifiers<AccessModifiers>([
-  "public",
-  "protected",
-  "private",
-  "internal",
-  "file",
-]);
+export type MethodModifier = "abstract" | "sealed" | "static" | "virtual";
+
+// maps the above method modifier value to its C# syntax.
+// note that the C# keyword includes a trailing space
+const methodModifierLookup: Record<MethodModifier, string> = {
+  abstract: "abstract ",
+  sealed: "sealed ",
+  static: "static ",
+  virtual: "virtual ",
+};
+
+// returns the C# syntax for the specified method modifier.
+// if no method modifier is specified, the empty string is returned.
+export function getMethodModifier(methodModifier?: MethodModifier): string {
+  return methodModifier ? methodModifierLookup[methodModifier] : "";
+}
 
 export function getAsyncModifier(async?: boolean): string {
-  return async ? "async" : "";
+  return async ? "async " : "";
 }
 
 /** Resolve the modifier prefix */
@@ -27,14 +53,5 @@ export function computeModifiersPrefix(
   modifiers: Array<string | undefined>,
 ): string {
   const resolved = modifiers.filter((x) => x);
-  return resolved.length > 0 ? resolved.join(" ") + " " : "";
-}
-
-export function makeModifiers<T>(obj: Array<keyof T>) {
-  return (data: T) => {
-    return obj
-      .map((key) => (data[key] ? key : undefined))
-      .filter((x) => x)
-      .join(" ");
-  };
+  return resolved.length > 0 ? resolved.join("") : "";
 }

package/src/name-policy.ts

@@ -5,16 +5,13 @@ import * as changecase from "change-case";
 export type CSharpElements =
   | "class"
   | "constant"
-  | "variable"
   | "enum"
   | "enum-member"
   | "function"
   | "interface"
-  | "record"
   | "class-member-private"
   | "class-member-public"
   | "class-method"
-  | "class-property"
   | "parameter"
   | "type-parameter";
 
@@ -26,11 +23,9 @@ export function createCSharpNamePolicy(): core.NamePolicy<CSharpElements> {
       case "enum":
       case "enum-member":
       case "interface":
-      case "record":
       case "class-member-public":
       case "class-method":
       case "type-parameter":
-      case "class-property":
         return changecase.pascalCase(name);
       case "constant":
         return changecase.constantCase(name);