@alloy-js/csharp 0.18.0-dev.3 → 0.18.0-dev.4

package/src/components/ClassMethod.tsx

@@ -7,12 +7,12 @@ import {
   Scope,
 } from "@alloy-js/core";
 import {
-  AccessModifier,
+  AccessModifiers,
   computeModifiersPrefix,
   getAccessModifier,
   getAsyncModifier,
   getMethodModifier,
-  MethodModifier,
+  MethodModifiers,
 } from "../modifiers.js";
 import { useCSharpNamePolicy } from "../name-policy.js";
 import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
@@ -20,12 +20,10 @@ import { CSharpMemberScope, useCSharpScope } from "../symbols/scopes.js";
 import { ParameterProps, Parameters } from "./Parameters.jsx";
 
 // properties for creating a method
-export interface ClassMethodProps {
+export interface ClassMethodProps extends AccessModifiers, MethodModifiers {
   name: string;
   refkey?: Refkey;
   children?: Children;
-  accessModifier?: AccessModifier;
-  methodModifier?: MethodModifier;
   parameters?: Array<ParameterProps>;
   returns?: Children;
 
@@ -58,8 +56,8 @@ 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
@@ -68,9 +66,7 @@ export function ClassMethod(props: ClassMethodProps) {
       <Scope value={methodScope}>
         {modifiers}
         {returns} {name}({params})
-        {props.methodModifier === "abstract" ?
-          ";"
-        : <Block newline>{props.children}</Block>}
+        {props.abstract ? ";" : <Block newline>{props.children}</Block>}
       </Scope>
     </MemberDeclaration>
   );

package/src/components/Enum.tsx

@@ -1,16 +1,19 @@
 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 EnumProps extends AccessModifiers {
   name: string;
   refkey?: core.Refkey;
   children?: core.Children;
-  accessModifier?: AccessModifier;
 }
 
 // a C# enum declaration
@@ -32,10 +35,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/modifiers.ts

@@ -1,51 +1,48 @@
 // 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";
 
-// 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] : "";
+/** Access modifiers.  */
+export interface AccessModifiers {
+  readonly public?: boolean;
+  readonly protected?: boolean;
+  readonly private?: boolean;
+  readonly internal?: boolean;
+  readonly file?: boolean;
 }
 
-export type MethodModifier = "abstract" | "sealed" | "static" | "virtual";
+export function getAccessModifier(data: AccessModifiers): string {
+  return [
+    data.public && "public",
+    data.protected && "protected",
+    data.private && "private",
+    data.internal && "internal",
+    data.file && "file",
+  ]
+    .filter((x) => x)
+    .join(" ");
+}
 
-// 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 ",
-};
+/** Method modifiers. Can only be one. */
+export interface MethodModifiers {
+  readonly abstract?: boolean;
+  readonly sealed?: boolean;
+  readonly static?: boolean;
+  readonly virtual?: boolean;
+}
 
-// 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 getMethodModifier(data: MethodModifiers): string {
+  return [
+    data.abstract && "abstract",
+    data.sealed && "sealed",
+    data.static && "static",
+    data.virtual && "virtual",
+  ]
+    .filter((x) => x)
+    .join(" ");
 }
 
 export function getAsyncModifier(async?: boolean): string {
-  return async ? "async " : "";
+  return async ? "async" : "";
 }
 
 /** Resolve the modifier prefix */
@@ -53,5 +50,5 @@ export function computeModifiersPrefix(
   modifiers: Array<string | undefined>,
 ): string {
   const resolved = modifiers.filter((x) => x);
-  return resolved.length > 0 ? resolved.join("") : "";
+  return resolved.length > 0 ? resolved.join(" ") + " " : "";
 }