@alloy-js/csharp 0.20.0-dev.1 → 0.20.0-dev.10

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alloy-js/csharp",
-  "version": "0.20.0-dev.1",
-  "description": "",
+  "version": "0.20.0-dev.10",
+  "description": "Alloy components for CSharp language.",
   "exports": {
     ".": {
       "import": "./dist/src/index.js"
@@ -10,21 +10,27 @@
       "import": "./dist/src/components/stc/index.js"
     }
   },
+  "imports": {
+    "#test/*": "./test/*",
+    "#components/*": {
+      "default": "./dist/src/components/*"
+    }
+  },
   "keywords": [],
   "author": "jhendrix@microsoft.com",
   "license": "MIT",
   "dependencies": {
-    "@alloy-js/core": "~0.19.0 || >= 0.20.0-dev.0",
+    "@alloy-js/core": "~0.19.0 || >= 0.20.0-dev.9",
     "change-case": "^5.4.4",
-    "marked": "^15.0.12",
+    "marked": "^16.1.1",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@alloy-js/cli": "~0.19.0 || >= 0.20.0-dev.0",
+    "@alloy-js/cli": "~0.19.0 || >= 0.20.0-dev.1",
     "@alloy-js/rollup-plugin": "~0.1.0 || >= 0.1.1-dev.0",
     "@microsoft/api-extractor": "~7.52.8",
     "@rollup/plugin-typescript": "^12.1.2",
-    "concurrently": "^9.1.2",
+    "concurrently": "^9.2.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },

package/src/components/Declaration.tsx

@@ -1,18 +1,15 @@
 import * as core from "@alloy-js/core";
-import { CSharpOutputSymbol } from "../symbols/csharp-output-symbol.js";
 
 // properties for creating a declaration
 export interface DeclarationProps {
   name: string;
-  refkey?: core.Refkey;
+  refkey?: core.Refkey | core.Refkey[];
   children?: core.Children;
 }
 
 // declares a symbol in the program (class, enum, interface etc)
 export function Declaration(props: DeclarationProps) {
-  const sym = new CSharpOutputSymbol(props.name, {
-    refkeys: props.refkey,
-  });
+  throw new Error("Not supported");
 
-  return <core.Declaration symbol={sym}>{props.children}</core.Declaration>;
+  //return <core.Declaration symbol={sym}>{props.children}</core.Declaration>;
 }

package/src/components/Reference.tsx

@@ -8,6 +8,8 @@ export interface ReferenceProps {
 // used to resolve refkey references within source files
 export function Reference({ refkey }: ReferenceProps) {
   const reference = ref(refkey);
+  const symbolRef = core.computed(() => reference()[1]);
 
-  return <>{reference}</>;
+  core.emitSymbol(symbolRef);
+  return <>{reference()[0]}</>;
 }

package/src/components/UsingDirective.tsx

@@ -1,13 +1,23 @@
 import * as core from "@alloy-js/core";
+import { NamespaceSymbol } from "../symbols/namespace.js";
 
 export interface UsingDirectiveProps {
-  namespaces: Array<string>;
+  /**
+   * Namespace symbols or namespace names to use to generate using statements.
+   */
+  namespaces?: (NamespaceSymbol | string)[];
 }
 
 // one ore more C# using directives
 export function UsingDirective(props: UsingDirectiveProps) {
   const sortedNamespaces = core.computed(() => {
-    return props.namespaces.sort();
+    return props
+      .namespaces!.map((ns) =>
+        typeof ns === "string" ? ns : (
+          ns.getFullyQualifiedName({ omitGlobal: true })
+        ),
+      )
+      .sort((n1, n2) => n1.localeCompare(n2));
   });
 
   return (

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

@@ -0,0 +1,284 @@
+import { ClassDeclaration } from "#components/class/declaration.jsx";
+import { Method } from "#components/method/method.jsx";
+import { TestNamespace } from "#test/utils.jsx";
+import { List, namekey, printTree, renderTree } from "@alloy-js/core";
+import { describe, expect, it } from "vitest";
+import { CSharpSymbol } from "../../symbols/csharp.js";
+import { AccessExpression } from "./access-expression.jsx";
+
+it("makes a member access expression", () => {
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" />
+      <AccessExpression.Part id="Bar" />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Foo.Bar`);
+});
+
+it("makes an element access expression", () => {
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" />
+      <AccessExpression.Part index={1} />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Foo[1]`);
+});
+
+it("makes a call expression", () => {
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" />
+      <AccessExpression.Part args={[1, 2, 3]} />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Foo(1, 2, 3)`);
+});
+
+it("makes an id part from a symbol", () => {
+  const symbol = new CSharpSymbol("Symbol", undefined);
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" />
+      <AccessExpression.Part symbol={symbol} />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Foo.Symbol`);
+});
+
+it("makes an id part from a symbol reactively", () => {
+  const symbol = new CSharpSymbol("Symbol", undefined);
+  const tree = renderTree(
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" />
+      <AccessExpression.Part symbol={symbol} />
+    </AccessExpression>,
+  );
+  expect(printTree(tree)).toEqual("Foo.Symbol");
+  symbol.name = "Bar";
+  expect(printTree(tree)).toEqual("Foo.Bar");
+});
+
+it("makes an id part from refkey, where the first part is a full reference, and subsequent parts are just the id", () => {
+  const methodKey = namekey("method");
+  const template = (
+    <TestNamespace>
+      <List>
+        <ClassDeclaration name="MyClass">
+          <Method name={methodKey} />
+        </ClassDeclaration>
+        <AccessExpression>
+          <AccessExpression.Part refkey={methodKey} />
+          <AccessExpression.Part refkey={methodKey} />
+        </AccessExpression>
+      </List>
+    </TestNamespace>
+  );
+
+  expect(template).toRenderTo(`
+    class MyClass
+    {
+        void Method() {}
+    }
+    MyClass.Method.Method
+  `);
+});
+
+it("takes type args", () => {
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" typeArgs={["Foo", "Bar"]} />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Foo<Foo, Bar>`);
+});
+
+it("takes multiple indexer arguments", () => {
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" />
+      <AccessExpression.Part indexerArgs={["arg1", "arg2"]} />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Foo[arg1, arg2]`);
+});
+
+it("allows nullable member access", () => {
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" nullable />
+      <AccessExpression.Part id="Bar" />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Foo?.Bar`);
+});
+
+it("allows conditional member access", () => {
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" />
+      <AccessExpression.Part id="Bar" conditional />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Foo?.Bar`);
+});
+
+it("allows nullable element access", () => {
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" nullable />
+      <AccessExpression.Part index={1} />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Foo?[1]`);
+});
+
+it("allows conditional element access", () => {
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part id="Foo" />
+      <AccessExpression.Part index={1} conditional />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Foo?[1]`);
+});
+
+it("uses symbol information for nullability", () => {
+  const symbol = new CSharpSymbol("Symbol", undefined, { isNullable: true });
+
+  const typeSymbol = new CSharpSymbol("SomeType", undefined, {
+    isNullable: true,
+  });
+
+  const typedSymbol = new CSharpSymbol("SomeValue", undefined, {
+    type: typeSymbol,
+  });
+
+  const template = (
+    <AccessExpression>
+      <AccessExpression.Part symbol={symbol} />
+      <AccessExpression.Part symbol={typedSymbol} />
+      <AccessExpression.Part id="Foo" />
+    </AccessExpression>
+  );
+  expect(template).toRenderTo(`Symbol?.SomeValue?.Foo`);
+});
+
+describe("formatting", () => {
+  it("breaks long identifier chains", () => {
+    const template = (
+      <AccessExpression>
+        <AccessExpression.Part id="Foo" />
+        <AccessExpression.Part id="Foo" />
+        <AccessExpression.Part id="Foo" />
+        <AccessExpression.Part id="Foo" />
+        <AccessExpression.Part id="Foo" />
+        <AccessExpression.Part id="Foo" />
+      </AccessExpression>
+    );
+    expect(template).toRenderTo(
+      `
+      Foo.Foo
+        .Foo.Foo
+        .Foo.Foo
+      `,
+      { printWidth: 10 },
+    );
+  });
+  it("breaks long call expressions", () => {
+    const template = (
+      <AccessExpression>
+        <AccessExpression.Part id="Foo" />
+        <AccessExpression.Part id="Bar" />
+        <AccessExpression.Part args={["variable1", "variable2", "variable3"]} />
+      </AccessExpression>
+    );
+    expect(template).toRenderTo(
+      `
+      Foo.Bar(
+        variable1,
+        variable2,
+        variable3
+      )
+      `,
+      { printWidth: 10 },
+    );
+  });
+
+  it("breaks long type args", () => {
+    const template = (
+      <AccessExpression>
+        <AccessExpression.Part
+          id="Foo"
+          typeArgs={["Foo", "Bar", "Baz", "Qux"]}
+        />
+      </AccessExpression>
+    );
+    expect(template).toRenderTo(
+      `
+      Foo<
+        Foo,
+        Bar,
+        Baz,
+        Qux
+      >
+      `,
+      { printWidth: 10 },
+    );
+  });
+
+  it("breaks long type args for second member", () => {
+    const template = (
+      <AccessExpression>
+        <AccessExpression.Part id="Foo" />
+        <AccessExpression.Part
+          id="Bar"
+          typeArgs={["Foo", "Bar", "Baz", "Qux"]}
+        />
+      </AccessExpression>
+    );
+    expect(template).toRenderTo(
+      `
+      Foo
+        .Bar<
+          Foo,
+          Bar,
+          Baz,
+          Qux
+        >
+      `,
+      { printWidth: 10 },
+    );
+  });
+
+  it("formats builder pattern", () => {
+    const template = (
+      <AccessExpression>
+        <AccessExpression.Part id="Foo" />
+        <AccessExpression.Part id="Bar" />
+        <AccessExpression.Part id="Baz" />
+        <AccessExpression.Part args />
+        <AccessExpression.Part id="Qux" />
+        <AccessExpression.Part id="Quux" typeArgs={["TTypeOne", "TTypeTwo"]} />
+        <AccessExpression.Part indexerArgs={["arg1", "arg2"]} />
+        <AccessExpression.Part args />
+      </AccessExpression>
+    );
+    expect(template).toRenderTo(
+      `
+        Foo.Bar
+          .Baz()
+          .Qux
+          .Quux<
+            TTypeOne,
+            TTypeTwo
+          >[
+            arg1,
+            arg2
+          ]()
+      `,
+      { printWidth: 10 },
+    );
+  });
+});