@alloy-js/csharp 0.21.0-dev.8 → 0.21.0

package/src/builtins/index.ts

@@ -0,0 +1,2 @@
+export { default as Microsoft } from "./Microsoft/index.js";
+export { default as System } from "./System/index.js";

package/src/components/access-expression/access-expression.tsx

@@ -5,7 +5,7 @@ import {
   computed,
   For,
   isComponentCreator,
-  Refkey,
+  Refkeyable,
   Show,
   takeSymbols,
 } from "@alloy-js/core";
@@ -92,7 +92,7 @@ export interface AccessExpressionPartProps {
    * A refkey for the symbol whose name becomes this part's identifier. When a refkey is provided for the first
    * part, it will be fully resolved. Otherwise, just the symbol's name is used.
    */
-  refkey?: Refkey;
+  refkey?: Refkeyable;
 
   /**
    * The symbol whose name becomes this part's identifier.
@@ -122,6 +122,12 @@ export interface AccessExpressionPartProps {
    * you provide a symbol or refkey and the symbol's nullable flag is set.
    */
   nullable?: boolean;
+
+  /**
+   * Wether this part is an attribute reference (used in an attribute context).
+   * In that case the "Attribute" suffix is trimmed from the name if present.
+   */
+  attribute?: boolean;
 }
 
 AccessExpression.Part = function (props: AccessExpressionPartProps) {

package/src/components/access-expression/part-descriptors.ts

@@ -128,9 +128,12 @@ function createPartDescriptorFromProps(
       } else if (first && partProps.refkey) {
         return partProps.refkey;
       } else if (partProps.id !== undefined) {
-        return partProps.id;
+        return normalizeIfAttribute(partProps.id, partProps.attribute);
       } else if (symbolSource.value) {
-        return escapeId(symbolSource.value.name);
+        return normalizeIfAttribute(
+          escapeId(symbolSource.value.name),
+          partProps.attribute,
+        );
       } else {
         return "<unresolved symbol>";
       }
@@ -173,3 +176,24 @@ function createPartDescriptorFromProps(
 function escapeId(id: string) {
   return id.replace(/"/g, '\\"');
 }
+
+function normalizeIfAttribute(id: string, isAttribute?: boolean) {
+  if (isAttribute) {
+    return normalizeAttributeName(id);
+  }
+  return id;
+}
+
+/**
+ * Normalize attribute name by removing the "Attribute" suffix if present.
+ * @example
+ * ```ts
+ * normalizeAttributeName("TestAttribute") // returns "Test"
+ * ```
+ */
+export function normalizeAttributeName(name: string) {
+  if (name !== undefined && name.endsWith("Attribute")) {
+    return name.substring(0, name.length - "Attribute".length);
+  }
+  return name;
+}

package/src/components/attributes/attributes.test.tsx

@@ -1,12 +1,53 @@
-import { expect, it } from "vitest";
+import { ClassDeclaration } from "#components/class/declaration.jsx";
+import { createLibrary } from "#createLibrary";
+import { TestNamespace } from "#test/utils.jsx";
+import { List, namekey } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
 import { Attribute, AttributeList } from "./attributes.jsx";
-
 it("define attribute", () => {
   expect(<Attribute name="Test" />).toRenderTo(`
       [Test]
   `);
 });
 
+describe("Attribute suffix trimming", () => {
+  it("define attribute whose name ending with 'Attribute'", () => {
+    expect(<Attribute name="TestAttribute" />).toRenderTo(`
+      [Test]
+    `);
+  });
+
+  it("when using namekey", () => {
+    const key = namekey("TestAttribute");
+    expect(
+      <TestNamespace>
+        <List>
+          <Attribute name={key} />
+          <ClassDeclaration name={key} />
+        </List>
+      </TestNamespace>,
+    ).toRenderTo(`
+      [Test]
+      class TestAttribute;
+    `);
+  });
+
+  it("when referenced from library", () => {
+    const TestLib = createLibrary("TestLib", {
+      TestAttribute: { kind: "method", methodKind: "ordinary" },
+    });
+    expect(
+      <TestNamespace>
+        <Attribute name={TestLib.TestAttribute} />
+      </TestNamespace>,
+    ).toRenderTo(`
+      using TestLib;
+      
+      [Test]
+    `);
+  });
+});
+
 it("define attribute with single arg", () => {
   expect(<Attribute name="Test" args={[`"abc"`]} />).toRenderTo(`
       [Test("abc")]

package/src/components/attributes/attributes.tsx

@@ -1,15 +1,13 @@
+import { normalizeAttributeName } from "#components/access-expression/part-descriptors.js";
 import {
   Children,
   findKeyedChildren,
   For,
   Indent,
+  Refkeyable,
   taggedComponent,
 } from "@alloy-js/core";
-
-export interface AttributeItem {
-  name: string;
-  args?: string[];
-}
+import { ReferenceContext } from "../../contexts/reference-context.js";
 
 export type AttributesProp = Array<string | AttributeProps | Children>;
 
@@ -54,7 +52,7 @@ function renderAttribute(attr: string | AttributeProps | Children): Children {
 
 export interface AttributeProps {
   /** Attribute name */
-  name: Children;
+  name: string | Refkeyable;
 
   /** Argument */
   args?: Children[];
@@ -81,7 +79,8 @@ export const Attribute = taggedComponent(
   (props: AttributeProps) => {
     return (
       <group>
-        [{props.name}
+        [
+        <AttributeName name={props.name} />
         {props.args && props.args.length > 0 && (
           <>
             (
@@ -98,3 +97,11 @@ export const Attribute = taggedComponent(
     );
   },
 );
+
+function AttributeName(props: Pick<AttributeProps, "name">) {
+  return typeof props.name === "string" ?
+      normalizeAttributeName(props.name)
+    : <ReferenceContext.Provider value={"attribute"}>
+        {props.name}
+      </ReferenceContext.Provider>;
+}

package/src/components/csproj-file/csproj-file.test.tsx

@@ -0,0 +1,38 @@
+import { Compile, ItemGroup } from "@alloy-js/msbuild/components";
+import { expect, it } from "vitest";
+import { CsprojFile } from "./csproj-file.jsx";
+
+it("create empty .csproj file", () => {
+  expect(<CsprojFile path={"foo.csproj"}>{"<!-- content -->"}</CsprojFile>)
+    .toRenderTo(`
+    <Project Sdk="Microsoft.NET.Sdk"><!-- content --></Project>
+  `);
+});
+
+it("set different sdk", () => {
+  expect(
+    <CsprojFile path={"foo.csproj"} sdk="Microsoft.NET.Sdk.Web">
+      {"<!-- content -->"}
+    </CsprojFile>,
+  ).toRenderTo(`
+    <Project Sdk="Microsoft.NET.Sdk.Web"><!-- content --></Project>
+  `);
+});
+
+it("can use msbuild components", () => {
+  expect(
+    <CsprojFile path={"foo.csproj"} sdk="Microsoft.NET.Sdk.Web">
+      <ItemGroup>
+        <Compile Include="Program.cs" />
+        <Compile Include="Other.cs" />
+      </ItemGroup>
+    </CsprojFile>,
+  ).toRenderTo(`
+    <Project Sdk="Microsoft.NET.Sdk.Web">
+      <ItemGroup>
+        <Compile Include="Program.cs" />
+        <Compile Include="Other.cs" />
+      </ItemGroup>
+    </Project>
+  `);
+});

package/src/components/csproj-file/csproj-file.tsx

@@ -0,0 +1,32 @@
+import { Children, SourceFile } from "@alloy-js/core";
+import { Project } from "@alloy-js/msbuild/components";
+
+export type CSharpProjectSdk =
+  | "Microsoft.NET.Sdk"
+  | "Microsoft.NET.Sdk.Web"
+  | "Microsoft.NET.Sdk.Worker"
+  | "Microsoft.NET.Sdk.Razor"
+  | "Microsoft.NET.Sdk.BlazorWebAssembly"
+  | "Aspire.AppHost.Sdk"
+  | "MSTest.Sdk";
+
+export interface CsprojProps {
+  path: `${string}.csproj`;
+  /**
+   * Project SDK https://learn.microsoft.com/en-us/dotnet/core/project-sdk/overview
+   * @default "Microsoft.NET.Sdk"
+   */
+  sdk?: CSharpProjectSdk;
+
+  /** Content inside <project> */
+  children?: Children;
+}
+
+/** Create a .csproj file */
+export function CsprojFile(props: CsprojProps) {
+  return (
+    <SourceFile path={props.path} filetype="xml" tabWidth={2}>
+      <Project Sdk={props.sdk ?? "Microsoft.NET.Sdk"}>{props.children}</Project>
+    </SourceFile>
+  );
+}

package/src/components/index.ts

@@ -1,6 +1,8 @@
+export * from "./access-expression/access-expression.jsx";
 export * from "./attributes/attributes.jsx";
 export * from "./class/declaration.jsx";
 export * from "./constructor/constructor.jsx";
+export * from "./csproj-file/csproj-file.jsx";
 export * from "./Declaration.js";
 export * from "./doc/comment.jsx";
 export * from "./doc/from-markdown.jsx";
@@ -18,10 +20,10 @@ export * from "./method/method.jsx";
 export * from "./Name.js";
 export { Namespace, type NamespaceProps } from "./namespace/namespace.jsx";
 export * from "./parameters/parameters.jsx";
-export * from "./ProjectDirectory.js";
 export * from "./property/property.jsx";
 export * from "./record/declaration.js";
 export * from "./Reference.js";
+export * from "./region/region.jsx";
 export * from "./source-file/source-file.jsx";
 export * from "./struct/declaration.jsx";
 export type { TypeParameterProps } from "./type-parameters/type-parameter.jsx";

package/src/components/parameters/parameters.test.tsx

@@ -1,3 +1,4 @@
+import { Attribute } from "#components/attributes/attributes.jsx";
 import { ClassDeclaration } from "#components/class/declaration.jsx";
 import { Method } from "#components/method/method.jsx";
 import { Property } from "#components/property/property.jsx";
@@ -115,3 +116,72 @@ it("members can be referenced when the parameter is nullable", () => {
       }
   `);
 });
+
+it("can attach attributes", () => {
+  expect(
+    <Wrapper>
+      <Method
+        name="MethodOne"
+        parameters={[
+          {
+            name: "param1",
+            type: "T1",
+            attributes: [<Attribute name="Test" />],
+          },
+          {
+            name: "param2",
+            type: "T2",
+            attributes: [<Attribute name="Test2" args={["arg1", "arg2"]} />],
+          },
+        ]}
+      />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+        void MethodOne(
+            [Test]
+            T1 param1,
+            [Test2(arg1, arg2)]
+            T2 param2
+        ) {}
+    }
+  `);
+});
+
+it("can add modifiers: in | out | ref", () => {
+  expect(
+    <Wrapper>
+      <Method
+        name="MethodOne"
+        parameters={[
+          {
+            name: "param1",
+            type: "T1",
+            ref: true,
+          },
+          {
+            name: "param2",
+            type: "T2",
+            in: true,
+          },
+          {
+            name: "param3",
+            type: "T3",
+            out: true,
+          },
+          {
+            name: "param4",
+            type: "T4",
+            refReadonly: true,
+          },
+        ]}
+      />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+        void MethodOne(ref T1 param1, in T2 param2, out T3 param3, ref readonly T4 param4) {}
+    }
+  `);
+});

package/src/components/parameters/parameters.tsx

@@ -9,6 +9,7 @@ import {
   Refkey,
 } from "@alloy-js/core";
 import { createParameterSymbol } from "../../symbols/factories.js";
+import { AttributeList, AttributesProp } from "../attributes/attributes.jsx";
 import { Name } from "../Name.jsx";
 
 export interface ParameterProps {
@@ -20,6 +21,42 @@ export interface ParameterProps {
   default?: Children;
 
   refkey?: Refkey;
+
+  /**
+   * Parameter modifier: The argument must be initialized before calling the method. The method can't assign a new value to the parameter. The compiler might create a temporary variable to hold a copy of the argument to in parameters.
+   * @see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#in-parameter-modifier
+   * */
+  in?: boolean;
+  /**
+   * Parameter modifier: The calling method isn't required to initialize the argument before calling the method. The method must assign a value to the parameter.
+   * @see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#out-parameter-modifier
+   * */
+  out?: boolean;
+  /**
+   * Parameter modifier: The argument must be initialized before calling the method. The method can assign a new value to the parameter, but isn't required to do so.
+   * @see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#ref-parameter-modifier
+   */
+  ref?: boolean;
+  /**
+   * Parameter modifier: The argument must be initialized before calling the method. The method can't assign a new value to the parameter.
+   * @see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters#ref-readonly-modifier
+   */
+  refReadonly?: boolean;
+
+  /**
+   * Define attributes to attach
+   * @example
+   * ```tsx
+   * <Parameter name="foo" type="string" attributes={[
+   *  <Attribute name="Test" />
+   * ]}>
+   * ```
+   * This will produce:
+   * ```csharp
+   * [Test] string foo
+   * ```
+   */
+  attributes?: AttributesProp;
 }
 
 /** Define a parameter to be used in class or interface method. */
@@ -32,8 +69,26 @@ export function Parameter(props: ParameterProps) {
     isNullable: props.optional,
   });
 
+  // Only one of in, out, ref, ref readonly can be specified
+  const modifiers: (keyof ParameterProps)[] = (
+    ["in", "out", "ref", "refReadonly"] as (keyof ParameterProps)[]
+  ).filter((k) => props[k]);
+
+  if (modifiers.length > 1) {
+    throw new Error(
+      `Only one of 'in', 'out', 'ref', 'ref readonly' can be specified for parameter '${
+        typeof props.name === "string" ? props.name : props.name.name
+      }'`,
+    );
+  }
+  const modifier =
+    modifiers.length === 0 ? ""
+    : modifiers[0] === "refReadonly" ? "ref readonly "
+    : modifiers[0] + " ";
   return (
     <Declaration symbol={memberSymbol}>
+      <AttributeList attributes={props.attributes} endline />
+      <>{modifier}</>
       <TypeSlot>{props.type}</TypeSlot>
       {props.optional ? "?" : ""} <Name />
       {props.default ? code` = ${props.default}` : ""}

package/src/components/region/region.test.tsx

@@ -0,0 +1,19 @@
+import { Children } from "@alloy-js/core/jsx-runtime";
+import { expect, it } from "vitest";
+import { TestNamespace } from "../../../test/utils.jsx";
+import { Region } from "./region.jsx";
+
+const Wrapper = (props: { name: string; children: Children }) => (
+  <TestNamespace>
+    <Region name={props.name}>{props.children}</Region>
+  </TestNamespace>
+);
+
+it("region test", () => {
+  expect(<Wrapper name="Test Region">// This is inside region</Wrapper>)
+    .toRenderTo(`
+      #region Test Region
+      // This is inside region
+      #endregion
+    `);
+});

package/src/components/region/region.tsx

@@ -0,0 +1,16 @@
+import { Children, code, List } from "@alloy-js/core";
+
+export interface RegionProps {
+  name: string;
+  children: Children;
+}
+
+export function Region(props: RegionProps) {
+  return (
+    <List>
+      {code`#region ${props.name}`}
+      {props.children}
+      {code`#endregion`}
+    </List>
+  );
+}

package/src/components/stc/index.ts

@@ -9,6 +9,5 @@ export const EnumDeclaration = core.stc(base.EnumDeclaration);
 export const EnumMember = core.stc(base.EnumMember);
 export const Parameter = core.stc(base.Parameter);
 export const Parameters = core.stc(base.Parameters);
-export const ProjectDirectory = core.stc(base.ProjectDirectory);
 export const UsingDirective = core.stc(base.Usings);
 export const StructDeclaration = core.stc(base.StructDeclaration);

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

@@ -1,5 +1,5 @@
 import { List, namekey, refkey } from "@alloy-js/core";
-import { expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { VarDeclaration } from "./declaration.jsx";
 
@@ -66,3 +66,17 @@ it("links namekey", () => {
       var testVar2 = testVar;
   `);
 });
+
+describe("modifiers", () => {
+  it.each(["const", "using"])("%s", (mod) => {
+    expect(
+      <TestNamespace>
+        <VarDeclaration {...{ [mod]: true }} name="test" type="object">
+          a
+        </VarDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+        ${mod} object test = a;
+    `);
+  });
+});

package/src/components/var/declaration.tsx

@@ -1,16 +1,19 @@
 import {
   Children,
+  createSymbolSlot,
   Declaration,
   DeclarationProps,
   Name,
   Namekey,
   Refkey,
 } from "@alloy-js/core";
+import { computeModifiersPrefix, makeModifiers } from "../../modifiers.js";
 import { createVariableSymbol } from "../../symbols/factories.js";
 
 /** Props for {@link VarDeclaration} component */
 export interface VarDeclarationProps
-  extends Omit<DeclarationProps, "nameKind"> {
+  extends Omit<DeclarationProps, "nameKind">,
+    VarModifiers {
   /** Variable name */
   name: string | Namekey;
   /** Type of the variable declaration. If not specified, defaults to "var" */
@@ -19,11 +22,18 @@ export interface VarDeclarationProps
   refkey?: Refkey;
   /** Variable value */
   children?: Children;
+}
 
+export interface VarModifiers {
   /** Constant variable. Add the const modifier. */
-  const?: boolean;
+  readonly const?: boolean;
+
+  /** Disposable variable. Add the using modifier. */
+  readonly using?: boolean;
 }
 
+const getModifiers = makeModifiers<VarModifiers>(["const", "using"]);
+
 /**
  * Render a variable declaration
  *
@@ -46,16 +56,22 @@ export interface VarDeclarationProps
  * ```
  */
 export function VarDeclaration(props: VarDeclarationProps) {
+  const TypeSlot = createSymbolSlot();
+  const ValueSlot = createSymbolSlot();
+
   const sym = createVariableSymbol(props.name, {
     refkeys: props.refkey,
+    type: props.type ? TypeSlot.firstSymbol : ValueSlot.firstSymbol,
   });
+
   if (props.const && !props.type) {
     throw new Error("Implicitly-typed variables cannot be constant");
   }
   return (
     <Declaration symbol={sym}>
-      {props.const ? "const " : ""}
-      {props.type ?? "var"} <Name /> = {props.children};
+      {computeModifiersPrefix([getModifiers(props)])}
+      <TypeSlot>{props.type ?? "var"}</TypeSlot> <Name /> ={" "}
+      <ValueSlot>{props.children}</ValueSlot>;
     </Declaration>
   );
 }

package/src/contexts/global-namespace.ts

@@ -7,9 +7,16 @@ export function useGlobalNamespace() {
 }
 
 const globalNamespaces = new WeakMap<Binder, NamespaceSymbol>();
-const defaultGlobalNamespace = new NamespaceSymbol("global", undefined, {
+let defaultGlobalNamespace = new NamespaceSymbol("global", undefined, {
   isGlobal: true,
 });
+
+export function resetGlobalNamespace() {
+  defaultGlobalNamespace = new NamespaceSymbol("global", undefined, {
+    isGlobal: true,
+  });
+}
+
 export function getGlobalNamespace(binder: Binder | undefined) {
   if (!binder) {
     return defaultGlobalNamespace;

package/src/contexts/reference-context.ts

@@ -0,0 +1,18 @@
+import { ComponentContext, createContext, useContext } from "@alloy-js/core";
+
+/** What kind of reference.
+ * - 'standard' Default reference nothing special.
+ * - 'attribute' means we are referencing an attribute and so the name should be trimmed of "Attribute" suffix.
+ */
+
+export type ReferenceContext = "standard" | "attribute";
+
+/**
+ * Provides scopes for instance and static private members.
+ */
+export const ReferenceContext: ComponentContext<ReferenceContext> =
+  createContext<ReferenceContext>();
+
+export function useReferenceContext(): "standard" | "attribute" {
+  return useContext(ReferenceContext) ?? "standard";
+}