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

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}` : ""}
@@ -51,9 +106,14 @@ export function Parameters(props: ParametersProps) {
     <group>
       {"("}
       {props.parameters && (
-        <Indent softline>
+        <Indent nobreak>
           <For each={props.parameters} joiner={", "}>
-            {(param) => <Parameter {...param} />}
+            {(param) => (
+              <>
+                <softline />
+                <Parameter {...param} />
+              </>
+            )}
           </For>
         </Indent>
       )}

package/src/components/property/property.test.tsx

@@ -207,3 +207,28 @@ it("specify attributes", () => {
     }
   `);
 });
+
+describe("format", () => {
+  it("split after = if initializer too long", () => {
+    expect(
+      <TestNamespace printWidth={60}>
+        <ClassDeclaration name="Test">
+          <Property
+            public
+            get
+            set
+            name="ThisIsAVeryLongPropertyName"
+            type="string"
+            initializer={`"Some very long initializer value"`}
+          />
+        </ClassDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      class Test
+      {
+          public string ThisIsAVeryLongPropertyName { get; set; } =
+              "Some very long initializer value";
+      }
+  `);
+  });
+});

package/src/components/property/property.tsx

@@ -1,7 +1,5 @@
 import {
-  Block,
   Children,
-  code,
   createSymbolSlot,
   List,
   MemberDeclaration,
@@ -142,15 +140,28 @@ export function Property(props: PropertyProps) {
       <AttributeList attributes={props.attributes} endline />
       {modifiers}
       <TypeSlot>{props.type}</TypeSlot>
-      {props.nullable && "?"} <MemberName />{" "}
-      <Block newline inline>
-        <List joiner=" ">
-          {props.get && "get;"}
-          {props.set && "set;"}
-          {props.init && "init;"}
-        </List>
-      </Block>
-      {props.initializer && code` = ${props.initializer};`}
+      {props.nullable && "?"} <MemberName /> {"{ "}
+      <List joiner=" ">
+        {props.get && "get;"}
+        {props.set && "set;"}
+        {props.init && "init;"}
+      </List>
+      {" }"}
+      {props.initializer && (
+        <PropertyInitializer>{props.initializer}</PropertyInitializer>
+      )}
     </MemberDeclaration>
   );
 }
+
+function PropertyInitializer(props: { children: Children }) {
+  return (
+    <group>
+      {" ="}
+      <indent>
+        <line />
+        {props.children};
+      </indent>
+    </group>
+  );
+}

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

@@ -1,5 +1,5 @@
 import { ClassDeclaration } from "#components/class/declaration.jsx";
-import { Namespace } from "#components/namespace.jsx";
+import { Namespace } from "#components/namespace/namespace.jsx";
 import { Children, FormatOptions, Indent, Output, Prose } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { CSharpFormatOptions } from "../../contexts/format-options.js";

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

@@ -1,4 +1,5 @@
 import { NamespaceScopes } from "#components/namespace-scopes.jsx";
+import { NamespaceName } from "#components/namespace/namespace-name.jsx";
 import { Reference } from "#components/Reference.jsx";
 import { Usings } from "#components/using/using.jsx";
 import {
@@ -42,7 +43,6 @@ export function SourceFile(props: SourceFileProps) {
   const nsContext = useNamespaceContext();
   const globalNs = getGlobalNamespace(useBinder());
   const nsSymbol = nsContext ? nsContext.symbol : globalNs;
-  const nsRef = nsContext ? nsContext.symbol.name : undefined;
   const usings = computed(() => {
     return (
       Array.from(sourceFileScope.usings) as (NamespaceSymbol | string)[]
@@ -78,7 +78,7 @@ export function SourceFile(props: SourceFileProps) {
         {nsSymbol === globalNs ?
           content
         : <>
-            namespace {nsRef}
+            namespace <NamespaceName symbol={nsSymbol} />
             {sourceFileScope.hasBlockNamespace ?
               <>
                 {" "}

package/src/components/source-file/using.test.tsx

@@ -2,7 +2,7 @@ import { ClassDeclaration } from "#components/class/declaration.jsx";
 import { EnumDeclaration } from "#components/enum/declaration.jsx";
 import { EnumMember } from "#components/enum/member.jsx";
 import { Method } from "#components/method/method.jsx";
-import { Namespace } from "#components/namespace.jsx";
+import { Namespace } from "#components/namespace/namespace.jsx";
 import { SourceFile } from "#components/source-file/source-file.jsx";
 import { Output, refkey } from "@alloy-js/core";
 import * as coretest from "@alloy-js/core/testing";

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" */
@@ -21,6 +24,16 @@ export interface VarDeclarationProps
   children?: Children;
 }
 
+export interface VarModifiers {
+  /** Constant variable. Add the const modifier. */
+  readonly const?: boolean;
+
+  /** Disposable variable. Add the using modifier. */
+  readonly using?: boolean;
+}
+
+const getModifiers = makeModifiers<VarModifiers>(["const", "using"]);
+
 /**
  * Render a variable declaration
  *
@@ -43,12 +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.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";
+}

package/src/create-library.test.tsx

@@ -0,0 +1,213 @@
+import { VarDeclaration } from "#components/index.js";
+import { InvocationExpression } from "#components/invocation-expression/invocation-expression.jsx";
+import { TestNamespace } from "#test/utils.jsx";
+import { List, memberRefkey, namekey, toRefkey } from "@alloy-js/core";
+import { beforeEach, expect, it } from "vitest";
+import { IO } from "./builtins/System/index.js";
+import {
+  getGlobalNamespace,
+  resetGlobalNamespace,
+} from "./contexts/global-namespace.js";
+import { createLibrary } from "./create-library.js";
+import { NamespaceSymbol } from "./symbols/namespace.js";
+
+beforeEach(() => {
+  resetGlobalNamespace();
+});
+
+it("Creates symbols on demand", () => {
+  const System = createLibrary("System", {
+    String: {
+      kind: "class",
+      members: {
+        Special: { kind: "class", members: { BeSpecial: { kind: "field" } } },
+        Substring: { kind: "method" },
+        Length: { kind: "field" },
+        Empty: { kind: "field", isStatic: true },
+      },
+    },
+  });
+
+  const globalNamespace = getGlobalNamespace(undefined);
+  const systemNs = globalNamespace.members.symbolNames.get("System")!;
+  expect(systemNs).toBeUndefined();
+  const _ = toRefkey(System);
+  const systemNs2 = globalNamespace.members.symbolNames.get("System")!;
+  expect(systemNs2).toBeDefined();
+});
+
+it("Can reference types which haven't been created yet", () => {
+  const System = createLibrary("System", {
+    String: {
+      kind: "class",
+      members: {
+        Special: { kind: "property", type: () => SomeNs.SomeType },
+      },
+    },
+  });
+
+  const SomeNs = createLibrary("SomeNs", {
+    SomeType: {
+      kind: "class",
+      members: {},
+    },
+  });
+
+  const globalNamespace = getGlobalNamespace(undefined);
+  const _ = toRefkey(System.String.Special);
+  const systemNs2 = globalNamespace.members.symbolNames.get("System")!;
+  expect(systemNs2).toBeDefined();
+  const someNs = globalNamespace.members.symbolNames.get("SomeNs")!;
+  expect(someNs).toBeDefined();
+});
+
+it("Works with nested namespaces", () => {
+  const IO = createLibrary("System.IO", {
+    BinaryReader: {
+      kind: "class",
+      members: {},
+    },
+  });
+
+  const globalNamespace = getGlobalNamespace(undefined);
+  const systemNs = globalNamespace.members.symbolNames.get("System")!;
+  expect(systemNs).toBeUndefined();
+  const _ = toRefkey(IO.BinaryReader);
+  const systemNs2 = globalNamespace.members.symbolNames.get("System")!;
+  expect(systemNs2).toBeDefined();
+});
+
+it("Doesn't create duplicate namespaces", () => {
+  const IO = createLibrary("System.IO", {
+    BinaryReader: { kind: "class", members: {} },
+    BinaryWriter: { kind: "class", members: {} },
+  });
+
+  const Collections = createLibrary("System.Collections", {
+    ArrayList: { kind: "class", members: {} },
+  });
+
+  const _refkeys = [
+    toRefkey(IO.BinaryReader),
+    toRefkey(IO.BinaryWriter),
+    toRefkey(Collections.ArrayList),
+  ];
+
+  const globalNamespace = getGlobalNamespace(undefined);
+  const systemNs = globalNamespace.members.symbolNames.get(
+    "System",
+  )! as NamespaceSymbol;
+  expect(systemNs).toBeDefined();
+  const ioNs = systemNs.members.symbolNames.get("IO")!;
+  expect(ioNs).toBeDefined();
+  const collectionsNs = systemNs.members.symbolNames.get("Collections")!;
+  expect(collectionsNs).toBeDefined();
+});
+
+it("renders as a refkey", () => {
+  const IO = createLibrary("System.IO", {
+    BinaryReader: {
+      kind: "class",
+      members: {},
+    },
+  });
+
+  expect(
+    <TestNamespace>
+      new <InvocationExpression target={IO.BinaryReader} />;
+    </TestNamespace>,
+  ).toRenderTo(`
+    using System.IO;
+
+    new BinaryReader();
+  `);
+});
+
+it("has a refkey getter", () => {
+  const IO = createLibrary("System.IO", {
+    BinaryReader: {
+      kind: "class",
+      members: {},
+    },
+  });
+
+  const ioKey = toRefkey(IO);
+  expect(ioKey).toBeDefined();
+  const brKey = toRefkey(IO.BinaryReader);
+  expect(brKey).toBeDefined();
+});
+
+it("works to reference members", () => {
+  const IO = createLibrary("System.IO", {
+    BinaryReader: {
+      kind: "class",
+      members: {
+        ReadString: { kind: "method" },
+      },
+    },
+  });
+
+  const reader = namekey("reader");
+
+  expect(
+    <TestNamespace>
+      <VarDeclaration name={reader} type={IO.BinaryReader}>
+        new <InvocationExpression target={IO.BinaryReader} />
+      </VarDeclaration>
+      <hbr />
+      <InvocationExpression
+        target={memberRefkey(reader, IO.BinaryReader.ReadString)}
+      />
+      ;
+    </TestNamespace>,
+  ).toRenderTo(`
+    using System.IO;
+
+    BinaryReader reader = new BinaryReader();
+    reader.ReadString();
+  `);
+});
+
+it("has built-ins available", () => {
+  const info = namekey("info");
+
+  const template = (
+    <TestNamespace>
+      <List>
+        <VarDeclaration name={info}>
+          new {IO.FileInfo}("test.txt")
+        </VarDeclaration>
+        <VarDeclaration name="directoryName">
+          {memberRefkey(info, "DirectoryName", "Length")}
+        </VarDeclaration>
+      </List>
+    </TestNamespace>
+  );
+
+  expect(template).toRenderTo(`
+    using System.IO;
+
+    var info = new FileInfo("test.txt");
+    var directoryName = info.DirectoryName?.Length;
+  `);
+});
+
+it("can render multiple times", () => {
+  const System = createLibrary("System", {
+    String: {
+      kind: "class",
+      members: {},
+    },
+  });
+  expect(<TestNamespace>{System.String}</TestNamespace>).toRenderTo(`
+    using System;
+
+    String
+  `);
+
+  expect(<TestNamespace>{System.String}</TestNamespace>).toRenderTo(`
+    using System;
+
+    String
+  `);
+});