@alloy-js/csharp 0.21.0-dev.0 → 0.21.0-dev.12

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.

package/src/components/enum/declaration.ref.test.tsx

@@ -1,4 +1,4 @@
-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 { d } from "@alloy-js/core/testing";

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

@@ -1,4 +1,5 @@
-import { toSourceText } from "#test/utils.jsx";
+import { TestNamespace, toSourceText } from "#test/utils.jsx";
+import { namekey } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
 import { EnumDeclaration } from "./declaration.jsx";
@@ -32,3 +33,15 @@ it("applies naming policy to enum and members", () => {
     }
   `);
 });
+
+it("takes a namekey", () => {
+  const key = namekey("my-enum");
+  const tree = (
+    <TestNamespace>
+      <EnumDeclaration name={key} />
+    </TestNamespace>
+  );
+  expect(tree).toRenderTo(`
+    enum MyEnum;
+  `);
+});

package/src/components/enum/declaration.tsx

@@ -3,6 +3,7 @@ import {
   Children,
   Declaration,
   MemberScope,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import {
@@ -17,7 +18,7 @@ import { Name } from "../Name.jsx";
 
 // properties for creating an enum
 export interface EnumDeclarationProps extends AccessModifiers {
-  name: string;
+  name: string | Namekey;
   refkey?: Refkey | Refkey[];
   children?: Children;
 }
@@ -43,9 +44,9 @@ export interface EnumDeclarationProps extends AccessModifiers {
  * ```
  */
 export function EnumDeclaration(props: EnumDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "enum");
-  const symbol = createNamedTypeSymbol(name, "enum", {
+  const symbol = createNamedTypeSymbol(props.name, "enum", {
     refkeys: props.refkey,
+    namePolicy: useCSharpNamePolicy().for("enum"),
   });
   const scope = createNamedTypeScope(symbol);
 

package/src/components/enum/member.test.tsx

@@ -1,4 +1,5 @@
-import { toSourceText } from "#test/utils.jsx";
+import { TestNamespace, toSourceText } from "#test/utils.jsx";
+import { namekey } from "@alloy-js/core";
 import { d } from "@alloy-js/core/testing";
 import { expect, it } from "vitest";
 import { EnumDeclaration } from "./declaration.jsx";
@@ -22,3 +23,23 @@ it("declares enum with members", () => {
     }
   `);
 });
+
+it("takes a namekey", () => {
+  const memberKey = namekey("MyMember");
+  const tree = (
+    <TestNamespace>
+      <EnumDeclaration name="Foo">
+        <EnumMember name={memberKey} />
+      </EnumDeclaration>
+      <hbr />
+      {memberKey};
+    </TestNamespace>
+  );
+  expect(tree).toRenderTo(`
+    enum Foo
+    {
+        MyMember
+    }
+    Foo.MyMember;
+  `);
+});

package/src/components/enum/member.tsx

@@ -1,11 +1,11 @@
-import { MemberDeclaration, MemberName, Refkey } from "@alloy-js/core";
+import { MemberDeclaration, MemberName, Namekey, Refkey } from "@alloy-js/core";
 import { useCSharpNamePolicy } from "../../name-policy.js";
 import { useNamedTypeScope } from "../../scopes/contexts.js";
 import { CSharpSymbol } from "../../symbols/csharp.js";
 
 // properties for creating a C# enum member
 export interface EnumMemberProps {
-  name: string;
+  name: string | Namekey;
   refkey?: Refkey;
 }
 
@@ -23,9 +23,9 @@ export function EnumMember(props: EnumMemberProps) {
     throw new Error("EnumMember must be used within an EnumDeclaration.");
   }
 
-  const name = useCSharpNamePolicy().getName(props.name, "enum-member");
-  const thisEnumValueSymbol = new CSharpSymbol(name, symbol.members, {
+  const thisEnumValueSymbol = new CSharpSymbol(props.name, symbol.members, {
     refkeys: props.refkey,
+    namePolicy: useCSharpNamePolicy().for("enum-member"),
   });
 
   return (

package/src/components/field/field.test.tsx

@@ -1,4 +1,4 @@
-import { List } from "@alloy-js/core";
+import { List, namekey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { ClassDeclaration } from "../class/declaration.jsx";
@@ -30,6 +30,19 @@ it("declares multiple fields", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <Wrapper>
+      <Field name={namekey("my-field")} type="string" public />
+    </Wrapper>,
+  ).toRenderTo(`
+    public class TestClass
+    {
+        public string MyField;
+    }
+  `);
+});
+
 describe("modifiers", () => {
   describe("access modifiers", () => {
     it.each(["public", "private", "protected", "internal"] as const)(

package/src/components/field/field.tsx

@@ -1,4 +1,4 @@
-import { Children, Declaration, Name, Refkey } from "@alloy-js/core";
+import { Children, Declaration, Name, Namekey, Refkey } from "@alloy-js/core";
 import {
   AccessModifiers,
   computeModifiersPrefix,
@@ -28,7 +28,7 @@ const getModifiers = makeModifiers<FieldModifiers>([
 ]);
 
 export interface FieldProps extends AccessModifiers, FieldModifiers {
-  name: string;
+  name: string | Namekey;
   type: Children;
   refkey?: Refkey;
   /** Doc comment */

package/src/components/if/if-statement.test.tsx

@@ -0,0 +1,26 @@
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { ElseClause, ElseIfClause, IfStatement } from "./if-statement.jsx";
+
+it("works with blocks", () => {
+  expect(
+    <>
+      <IfStatement condition="x === 1">// do thing</IfStatement>
+      <ElseIfClause condition="x === 2">// do another thing</ElseIfClause>
+      <ElseClause>// do default thing</ElseClause>
+    </>,
+  ).toRenderTo(d`
+    if (x === 1)
+    {
+      // do thing
+    }
+    else if (x === 2)
+    {
+      // do another thing
+    }
+    else
+    {
+      // do default thing
+    }
+  `);
+});

package/src/components/if/if-statement.tsx

@@ -0,0 +1,50 @@
+import { Block, type Children } from "@alloy-js/core";
+
+export interface IfStatementProps {
+  condition: Children;
+  children: Children;
+}
+
+/**
+ * An if statement.
+ */
+export function IfStatement(props: IfStatementProps) {
+  return (
+    <>
+      if ({props.condition}) <Block newline>{props.children}</Block>
+    </>
+  );
+}
+
+export interface ElseIfClauseProps {
+  condition: Children;
+  children: Children;
+}
+
+/**
+ * An else clause with an if statement.
+ */
+export function ElseIfClause(props: ElseIfClauseProps) {
+  return (
+    <>
+      <hardline />
+      else if ({props.condition}) <Block newline>{props.children}</Block>
+    </>
+  );
+}
+
+export interface ElseClauseProps {
+  children: Children;
+}
+
+/**
+ * The else clause of an if statement.
+ */
+export function ElseClause(props: ElseClauseProps) {
+  return (
+    <>
+      <hardline />
+      else <Block newline>{props.children}</Block>
+    </>
+  );
+}

package/src/components/index.ts

@@ -1,3 +1,4 @@
+export * from "./access-expression/access-expression.jsx";
 export * from "./attributes/attributes.jsx";
 export * from "./class/declaration.jsx";
 export * from "./constructor/constructor.jsx";
@@ -7,6 +8,7 @@ export * from "./doc/from-markdown.jsx";
 export * from "./enum/declaration.jsx";
 export * from "./enum/member.jsx";
 export * from "./field/field.jsx";
+export * from "./if/if-statement.jsx";
 export * from "./interface/declaration.js";
 export * from "./interface/method.js";
 export * from "./interface/property.js";
@@ -15,7 +17,7 @@ export * from "./lexical-scope.jsx";
 export * from "./method-scope.jsx";
 export * from "./method/method.jsx";
 export * from "./Name.js";
-export * from "./namespace.js";
+export { Namespace, type NamespaceProps } from "./namespace/namespace.jsx";
 export * from "./parameters/parameters.jsx";
 export * from "./ProjectDirectory.js";
 export * from "./property/property.jsx";
@@ -24,5 +26,5 @@ export * from "./Reference.js";
 export * from "./source-file/source-file.jsx";
 export * from "./struct/declaration.jsx";
 export type { TypeParameterProps } from "./type-parameters/type-parameter.jsx";
-export * from "./UsingDirective.js";
+export * from "./using/using.jsx";
 export * from "./var/declaration.jsx";

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

@@ -1,4 +1,4 @@
-import { List, refkey } from "@alloy-js/core";
+import { List, namekey, refkey } from "@alloy-js/core";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { Attribute } from "../attributes/attributes.jsx";
@@ -59,6 +59,16 @@ it("specify doc comment", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <TestNamespace>
+      <InterfaceDeclaration name={namekey("my-interface")} />
+    </TestNamespace>,
+  ).toRenderTo(`
+    interface MyInterface;
+  `);
+});
+
 describe("with type parameters", () => {
   it("reference parameters", () => {
     const typeParameters: TypeParameterProps[] = [

package/src/components/interface/declaration.tsx

@@ -26,7 +26,7 @@ export interface InterfaceDeclarationProps
   extends Omit<core.DeclarationProps, "nameKind">,
     AccessModifiers,
     InterfaceModifiers {
-  name: string;
+  name: string | core.Namekey;
 
   /** Doc comment */
   doc?: core.Children;
@@ -86,10 +86,9 @@ export interface InterfaceDeclarationProps
  * ```
  */
 export function InterfaceDeclaration(props: InterfaceDeclarationProps) {
-  const name = useCSharpNamePolicy().getName(props.name!, "interface");
-
-  const symbol = createNamedTypeSymbol(name, "interface", {
+  const symbol = createNamedTypeSymbol(props.name!, "interface", {
     refkeys: props.refkey,
+    namePolicy: useCSharpNamePolicy().for("interface"),
   });
 
   // this creates a new scope for the interface definition.

package/src/components/interface/method.test.tsx

@@ -1,4 +1,4 @@
-import { refkey } from "@alloy-js/core";
+import { namekey, refkey } from "@alloy-js/core";
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { describe, expect, it } from "vitest";
 import { TestNamespace } from "../../../test/utils.jsx";
@@ -188,6 +188,19 @@ it("specify attributes", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <Wrapper>
+      <InterfaceMethod name={namekey("my-method")} />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+        void MyMethod();
+    }
+  `);
+});
+
 describe("with type parameters", () => {
   it("reference parameters", () => {
     const typeParameters: TypeParameterProps[] = [

package/src/components/interface/method.tsx

@@ -3,6 +3,7 @@ import {
   Children,
   MemberDeclaration,
   MemberName,
+  Namekey,
   Refkey,
   Scope,
 } from "@alloy-js/core";
@@ -32,7 +33,7 @@ const getMethodModifier = makeModifiers<InterfaceMethodModifiers>(["new"]);
 export interface InterfaceMethodProps
   extends AccessModifiers,
     InterfaceMethodModifiers {
-  name: string;
+  name: string | Namekey;
   refkey?: Refkey;
   children?: Children;
   parameters?: Array<ParameterProps>;

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

@@ -1,5 +1,6 @@
 import { Children } from "@alloy-js/core/jsx-runtime";
 import { describe, expect, it } from "vitest";
+import { namekey } from "../../../../core/src/refkey.js";
 import { TestNamespace } from "../../../test/utils.jsx";
 import { Attribute } from "../attributes/attributes.jsx";
 import { InterfaceDeclaration } from "./declaration.jsx";
@@ -144,6 +145,18 @@ it("specify doc comment", () => {
   `);
 });
 
+it("takes a namekey", () => {
+  expect(
+    <Wrapper>
+      <InterfaceProperty name={namekey("my-property")} type="string" get />
+    </Wrapper>,
+  ).toRenderTo(`
+    public interface TestInterface
+    {
+        string MyProperty { get; }
+    }
+  `);
+});
 it("specify attributes", () => {
   expect(
     <Wrapper>

package/src/components/interface/property.tsx

@@ -4,6 +4,7 @@ import {
   List,
   MemberDeclaration,
   MemberName,
+  Namekey,
   Refkey,
 } from "@alloy-js/core";
 import {
@@ -27,7 +28,7 @@ const getModifiers = makeModifiers<InterfacePropertyModifiers>(["new"]);
 export interface InterfacePropertyProps
   extends AccessModifiers,
     InterfacePropertyModifiers {
-  name: string;
+  name: string | Namekey;
   refkey?: Refkey;
 
   /** Property type */

package/src/components/method/method.test.tsx

@@ -158,3 +158,52 @@ it("use expression body form", () => {
     }
   `);
 });
+
+describe("format", () => {
+  it("split expression after => if too long", () => {
+    expect(
+      <TestNamespace printWidth={60}>
+        <ClassDeclaration name="Test">
+          <Method public override name="ThisIsAVeryLongMethodName" expression>
+            this.WithAVeryLongPropertyName.AndAnEvenLongerMemberName
+          </Method>
+        </ClassDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      class Test
+      {
+          public override void ThisIsAVeryLongMethodName() =>
+              this.WithAVeryLongPropertyName.AndAnEvenLongerMemberName;
+      }
+  `);
+  });
+
+  it("split parameters first if too long", () => {
+    expect(
+      <TestNamespace printWidth={60}>
+        <ClassDeclaration name="Test">
+          <Method
+            public
+            override
+            name="ThisIsAVeryLongMethodName"
+            expression
+            parameters={[
+              { name: "firstParameter", type: "int" },
+              { name: "secondParameter", type: "string" },
+            ]}
+          >
+            this.Short
+          </Method>
+        </ClassDeclaration>
+      </TestNamespace>,
+    ).toRenderTo(`
+      class Test
+      {
+          public override void ThisIsAVeryLongMethodName(
+              int firstParameter,
+              string secondParameter
+          ) => this.Short;
+      }
+  `);
+  });
+});

package/src/components/method/method.tsx

@@ -154,9 +154,12 @@ export function Method(props: MethodProps) {
 
 const ExpressionBody = (props: { children?: Children }) => {
   return (
-    <>
-      {" => "}
-      {props.children};
-    </>
+    <group>
+      {" =>"}
+      <indent>
+        <line />
+        {props.children};
+      </indent>
+    </group>
   );
 };

package/src/components/namespace/namespace-name.tsx

@@ -0,0 +1,31 @@
+import { useNamespaceContext } from "../../contexts/namespace.js";
+import { NamespaceSymbol } from "../../symbols/namespace.js";
+
+/** @internal */
+export interface NamespaceNameProps {
+  symbol: NamespaceSymbol;
+
+  /** If it should print relative to the parent context */
+  relative?: boolean;
+}
+
+/** @internal */
+export function NamespaceName(props: NamespaceNameProps) {
+  const names = [props.symbol.name];
+  const parent = props.relative ? useNamespaceContext()?.symbol : undefined;
+
+  let current = props.symbol.ownerSymbol;
+  while (current) {
+    if (
+      current === parent ||
+      !(current instanceof NamespaceSymbol) ||
+      current.isGlobal
+    ) {
+      break;
+    }
+    names.unshift(current.name);
+    current = current.ownerSymbol;
+  }
+
+  return names.join(".");
+}

package/src/components/namespace/namespace.test.tsx

@@ -0,0 +1,145 @@
+import { TestNamespace } from "#test/utils.jsx";
+import { Output } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { expect, it } from "vitest";
+import { ClassDeclaration } from "../class/declaration.jsx";
+import { SourceFile } from "../source-file/source-file.jsx";
+import { Namespace } from "./namespace.jsx";
+
+it("defines multiple namespaces and source files with unique content", () => {
+  const tree = (
+    <Output>
+      <Namespace name="Namespace1">
+        <SourceFile path="Model1.cs">
+          <ClassDeclaration public name="Model1" />
+        </SourceFile>
+        <SourceFile path="Model2.cs">
+          <ClassDeclaration public name="Model2" />
+        </SourceFile>
+      </Namespace>
+      <Namespace name="Namespace2">
+        <SourceFile path="Model3.cs">
+          <ClassDeclaration public name="Model3" />
+        </SourceFile>
+        <SourceFile path="Model4.cs">
+          <ClassDeclaration public name="Model4" />
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo({
+    "Model1.cs": d`
+      namespace Namespace1;
+
+      public class Model1;
+    `,
+    "Model2.cs": d`
+      namespace Namespace1;
+
+      public class Model2;
+    `,
+    "Model3.cs": d`
+      namespace Namespace2;
+      
+      public class Model3;
+    `,
+    "Model4.cs": d`
+      namespace Namespace2;
+      
+      public class Model4;
+    `,
+  });
+});
+
+it("nest namespaces", () => {
+  const tree = (
+    <Output>
+      <Namespace name={["Namespace1"]}>
+        <Namespace name={["Namespace2"]}>
+          <SourceFile path="Model1.cs">
+            <ClassDeclaration public name="Model1" />
+          </SourceFile>
+        </Namespace>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    namespace Namespace1.Namespace2;
+
+    public class Model1;
+  `);
+});
+
+it("define nested namespace directly with array", () => {
+  const tree = (
+    <Output>
+      <Namespace name={["Namespace1", "Namespace2"]}>
+        <SourceFile path="Model1.cs">
+          <ClassDeclaration public name="Model1" />
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    namespace Namespace1.Namespace2;
+
+    public class Model1;
+  `);
+});
+
+it("define nested namespace directly as dotted notation", () => {
+  const tree = (
+    <Output>
+      <Namespace name="Namespace1.Namespace2">
+        <SourceFile path="Model1.cs">
+          <ClassDeclaration public name="Model1" />
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo({
+    "Model1.cs": d`
+      namespace Namespace1.Namespace2;
+
+      public class Model1;
+    `,
+  });
+});
+
+it("uses a name policy", () => {
+  expect(
+    <TestNamespace>
+      <Namespace name="my-namespace" />
+    </TestNamespace>,
+  ).toRenderTo(`
+    namespace MyNamespace {
+
+    }
+  `);
+});
+
+it("define nested namespace in sourcefile", () => {
+  const tree = (
+    <Output>
+      <Namespace name="Base">
+        <SourceFile path="Model1.cs">
+          <Namespace name="Namespace1.Namespace2">
+            <ClassDeclaration public name="Model1" />
+          </Namespace>
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+
+  expect(tree).toRenderTo(`
+    namespace Base {
+        namespace Namespace1.Namespace2 {
+            public class Model1;
+        }
+    }
+  `);
+});